diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
new file mode 100644
index 0000000..86c10c8
--- /dev/null
+++ b/.vscode/c_cpp_properties.json
@@ -0,0 +1,27 @@
+{
+    "configurations": [
+        {
+            "name": "Mac",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/external/qemu/android/android-emugl/guest",
+                "${workspaceFolder}/device/generic/goldfish-opengl/system/OpenglSystemCommon",
+                "${workspaceFolder}/device/generic/goldfish-opengl/shared/OpenglCodecCommon"
+            ],
+            "defines": [
+                "HOST_BUILD",
+                "GOLDFISH_VULKAN"
+            ],
+            "macFrameworkPath": [
+                "/System/Library/Frameworks",
+                "/Library/Frameworks"
+            ],
+            "compilerPath": "/usr/bin/clang",
+            "cStandard": "c11",
+            "cppStandard": "c++14",
+            "intelliSenseMode": "clang-x64",
+            "configurationProvider": "vector-of-bool.cmake-tools"
+        }
+    ],
+    "version": 4
+}
\ No newline at end of file
diff --git a/Android.mk b/Android.mk
index d598d71..9235b63 100644
--- a/Android.mk
+++ b/Android.mk
@@ -7,22 +7,71 @@
 # Also define BUILD_EMULATOR_OPENGL_DRIVER to 'true' to build the gralloc
 # stuff as well.
 #
-ifeq (true,$(BUILD_EMULATOR_OPENGL))
-
 # Top-level for all modules
-EMUGL_PATH := $(call my-dir)
+GOLDFISH_OPENGL_PATH := $(call my-dir)
+
+# There are two kinds of builds for goldfish-opengl:
+# 1. The standard guest build, denoted by BUILD_EMULATOR_OPENGL
+# 2. The host-side build, denoted by GOLDFISH_OPENGL_BUILD_FOR_HOST
+#
+# Variable controlling whether the build for goldfish-opengl
+# libraries (including their Android.mk's) should be triggered.
+GOLDFISH_OPENGL_SHOULD_BUILD := false
+
+# In the host build, some libraries have name collisions with
+# other libraries, so we have this variable here to control
+# adding a suffix to the names of libraries. Should be blank
+# for the guest build.
+GOLDFISH_OPENGL_LIB_SUFFIX :=
 
 # Directory containing common headers used by several modules
 # This is always set to a module's LOCAL_C_INCLUDES
 # See the definition of emugl-begin-module in common.mk
-#
-EMUGL_COMMON_INCLUDES := $(EMUGL_PATH)/host/include/libOpenglRender $(EMUGL_PATH)/system/include
+EMUGL_COMMON_INCLUDES := $(GOLDFISH_OPENGL_PATH)/host/include/libOpenglRender $(GOLDFISH_OPENGL_PATH)/system/include
 
 # common cflags used by several modules
 # This is always set to a module's LOCAL_CFLAGS
 # See the definition of emugl-begin-module in common.mk
-#
-EMUGL_COMMON_CFLAGS := -DWITH_GLES2 -DPLATFORM_SDK_VERSION=$(PLATFORM_SDK_VERSION)
+EMUGL_COMMON_CFLAGS := -DWITH_GLES2
+
+# Whether or not to build the Vulkan library.
+BUILD_EMULATOR_VULKAN := false
+
+# Host build
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+GOLDFISH_OPENGL_SHOULD_BUILD := true
+GOLDFISH_OPENGL_LIB_SUFFIX := _host
+
+BUILD_EMULATOR_VULKAN := true
+
+# Set modern defaults for the codename, version, etc.
+PLATFORM_VERSION_CODENAME:=Q
+PLATFORM_SDK_VERSION:=29
+IS_AT_LEAST_OPD1:=true
+
+# The host-side Android framework implementation
+HOST_EMUGL_PATH := $(GOLDFISH_OPENGL_PATH)/../../../external/qemu/android/android-emugl
+EMUGL_COMMON_INCLUDES += $(HOST_EMUGL_PATH)/guest
+
+EMUGL_COMMON_CFLAGS += \
+    -DPLATFORM_SDK_VERSION=29 \
+    -DGOLDFISH_HIDL_GRALLOC \
+    -DEMULATOR_OPENGL_POST_O=1 \
+    -DHOST_BUILD \
+    -DANDROID \
+    -DGL_GLEXT_PROTOTYPES \
+    -fvisibility=default \
+    -DPAGE_SIZE=4096 \
+    -DGOLDFISH_VULKAN \
+
+endif # GOLDFISH_OPENGL_BUILD_FOR_HOST
+
+ifeq (true,$(BUILD_EMULATOR_OPENGL)) # Guest build
+
+GOLDFISH_OPENGL_SHOULD_BUILD := true
+
+EMUGL_COMMON_CFLAGS += -DPLATFORM_SDK_VERSION=$(PLATFORM_SDK_VERSION)
 
 ifeq (O, $(PLATFORM_VERSION_CODENAME))
 EMUGL_COMMON_CFLAGS += -DGOLDFISH_HIDL_GRALLOC
@@ -49,15 +98,24 @@
     EMUGL_COMMON_CFLAGS += -DALOGV=LOGV
 endif
 
-# Uncomment the following line if you want to enable debug traces
-# in the GLES emulation libraries.
-# EMUGL_COMMON_CFLAGS += -DEMUGL_DEBUG=1
+ifeq ($(shell test $(PLATFORM_SDK_VERSION) -gt 27 && echo isApi28OrHigher),isApi28OrHigher)
+    BUILD_EMULATOR_VULKAN := true
+    EMUGL_COMMON_CFLAGS += -DGOLDFISH_VULKAN
+endif
 
 # Include common definitions used by all the modules included later
 # in this build file. This contains the definition of all useful
 # emugl-xxxx functions.
 #
-include $(EMUGL_PATH)/common.mk
+include $(GOLDFISH_OPENGL_PATH)/common.mk
+
+endif # BUILD_EMULATOR_OPENGL (guest build)
+
+ifeq (true,$(GOLDFISH_OPENGL_SHOULD_BUILD))
+
+# Uncomment the following line if you want to enable debug traces
+# in the GLES emulation libraries.
+# EMUGL_COMMON_CFLAGS += -DEMUGL_DEBUG=1
 
 # IMPORTANT: ORDER IS CRUCIAL HERE
 #
@@ -71,20 +129,35 @@
 # Note that the build system will complain if you try to import a
 # module that hasn't been declared yet anyway.
 #
+include $(GOLDFISH_OPENGL_PATH)/shared/OpenglCodecCommon/Android.mk
 
-include $(EMUGL_PATH)/shared/OpenglCodecCommon/Android.mk
+# Encoder shared libraries
+include $(GOLDFISH_OPENGL_PATH)/system/GLESv1_enc/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/system/GLESv2_enc/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/system/renderControl_enc/Android.mk
 
-# System static libraries
-include $(EMUGL_PATH)/system/GLESv1_enc/Android.mk
-include $(EMUGL_PATH)/system/GLESv2_enc/Android.mk
-include $(EMUGL_PATH)/system/renderControl_enc/Android.mk
-include $(EMUGL_PATH)/system/OpenglSystemCommon/Android.mk
+ifeq (true,$(BUILD_EMULATOR_VULKAN)) # Vulkan libs
+    include $(GOLDFISH_OPENGL_PATH)/android-emu/Android.mk
+    include $(GOLDFISH_OPENGL_PATH)/system/vulkan_enc/Android.mk
+endif
+
+include $(GOLDFISH_OPENGL_PATH)/system/OpenglSystemCommon/Android.mk
 
 # System shared libraries
-include $(EMUGL_PATH)/system/GLESv1/Android.mk
-include $(EMUGL_PATH)/system/GLESv2/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/system/GLESv1/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/system/GLESv2/Android.mk
 
-include $(EMUGL_PATH)/system/gralloc/Android.mk
-include $(EMUGL_PATH)/system/egl/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/system/gralloc/Android.mk
 
-endif # BUILD_EMULATOR_OPENGL == true
+include $(GOLDFISH_OPENGL_PATH)/system/egl/Android.mk
+
+ifeq (true,$(BUILD_EMULATOR_VULKAN)) # Vulkan libs
+    include $(GOLDFISH_OPENGL_PATH)/system/vulkan/Android.mk
+endif
+
+ifeq ($(shell test $(PLATFORM_SDK_VERSION) -gt 28 -o $(IS_AT_LEAST_QPR1) = true && echo isApi29OrHigher),isApi29OrHigher)
+    # HWC2 enabled after P
+    include $(GOLDFISH_OPENGL_PATH)/system/hwc2/Android.mk
+endif
+
+endif
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..ac15aad
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,17 @@
+# This is an autogenerated file! Do not edit!
+# 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" "8a354859d6be293140931db80edcbaf2c4db30118482356373f9ed2c92059806")
+add_subdirectory(shared/OpenglCodecCommon)
+add_subdirectory(system/GLESv1_enc)
+add_subdirectory(system/GLESv2_enc)
+add_subdirectory(system/renderControl_enc)
+add_subdirectory(android-emu)
+add_subdirectory(system/vulkan_enc)
+add_subdirectory(system/OpenglSystemCommon)
+add_subdirectory(system/GLESv1)
+add_subdirectory(system/GLESv2)
+add_subdirectory(system/gralloc)
+add_subdirectory(system/egl)
+add_subdirectory(system/vulkan)
\ No newline at end of file
diff --git a/GNUmakefile b/GNUmakefile
new file mode 100644
index 0000000..0610f29
--- /dev/null
+++ b/GNUmakefile
@@ -0,0 +1,60 @@
+# Copyright 2018 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.
+#
+
+# Check that we have at least GNU Make 3.81
+# We do this by detecting whether 'lastword' is supported
+#
+MAKE_TEST := $(lastword a b c d e f)
+ifneq ($(MAKE_TEST),f)
+    $(error,This build system requires GNU Make 3.81 or higher to run !)
+endif
+
+# Find the source installation path, should be this file's location.
+_BUILD_ROOT := $(dir $(lastword $(MAKEFILE_LIST)))
+_BUILD_ROOT := $(_BUILD_ROOT:%/=%)
+
+# Complain if the path contains spaces
+ifneq ($(words $(_BUILD_ROOT)),1)
+    $(info,The source installation path contains spaces: '$(_BUILD_ROOT)')
+    $(error,Please fix the problem by reinstalling to a different location.)
+endif
+
+# We are going to generate a JSON representation from the build
+GOLDFISH_OPENGL_BUILD_FOR_HOST := true
+CMAKE_GENERATE := true
+_BUILD_CORE_DIR  := ../../../external/qemu/android/build
+
+# We need the emulator's android makefile defs, so we can understand
+# the makefiles.
+include $(_BUILD_CORE_DIR)/emulator/definitions.make
+
+# We need the ability to dump json.
+include $(_BUILD_ROOT)/json-dump.mk
+
+# And we are going to build like we are an emulator host.
+include $(_BUILD_ROOT)/common.mk
+include $(_BUILD_ROOT)/Android.mk
+
+JSON_FILE := /tmp/build.json
+JSON_DUMP := [ "" $(JSON_DUMP) ]
+
+# And we are going to transform our generated json list into a set of 
+# cmake files.
+
+# This is the first target, so also the default target
+cmake:
+	@rm -f $(JSON_FILE)
+	$(call write-to-file,$(JSON_FILE),30,$(JSON_DUMP))
+	$(hide) python cmake_transform.py -i $(JSON_FILE) -c $(JSON_FILE) -o ${_BUILD_ROOT} 
\ No newline at end of file
diff --git a/android-emu/Android.mk b/android-emu/Android.mk
new file mode 100644
index 0000000..0e02fc1
--- /dev/null
+++ b/android-emu/Android.mk
@@ -0,0 +1,22 @@
+LOCAL_PATH := $(call my-dir)
+
+$(call emugl-begin-static-library,libandroidemu)
+$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
+$(call emugl-export,SHARED_LIBRARIES,libcutils libutils liblog)
+
+LOCAL_CFLAGS += \
+    -DLOG_TAG=\"androidemu\" \
+    -Wno-missing-field-initializers \
+    -fvisibility=default \
+    -fstrict-aliasing \
+
+LOCAL_SRC_FILES := \
+    android/base/AlignedBuf.cpp \
+    android/base/files/MemStream.cpp \
+    android/base/files/Stream.cpp \
+    android/base/files/StreamSerializing.cpp \
+    android/base/Pool.cpp \
+    android/base/StringFormat.cpp \
+    android/utils/debug.c \
+
+$(call emugl-end-module)
diff --git a/android-emu/CMakeLists.txt b/android-emu/CMakeLists.txt
new file mode 100644
index 0000000..9e3218d
--- /dev/null
+++ b/android-emu/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/android-emu/Android.mk" "4b9cd7741f05b6dd1384a3dbc317d971365ed9c96ee19f42c1dcc075a2df10ba")
+set(androidemu_src android/base/AlignedBuf.cpp android/base/files/MemStream.cpp android/base/files/Stream.cpp android/base/files/StreamSerializing.cpp android/base/Pool.cpp android/base/StringFormat.cpp android/utils/debug.c)
+android_add_library(androidemu)
+target_include_directories(androidemu PRIVATE ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(androidemu PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"androidemu\"")
+target_compile_options(androidemu PRIVATE "-fvisibility=default" "-Wno-missing-field-initializers" "-fstrict-aliasing")
+target_link_libraries(androidemu PRIVATE cutils utils log OpenglCodecCommon_host android-emu-shared)
\ No newline at end of file
diff --git a/android-emu/android/base/AlignedBuf.cpp b/android-emu/android/base/AlignedBuf.cpp
new file mode 100644
index 0000000..a1bc6f3
--- /dev/null
+++ b/android-emu/android/base/AlignedBuf.cpp
@@ -0,0 +1,45 @@
+// Copyright 2018 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 "AlignedBuf.h"
+
+namespace android {
+
+// Convenience function for aligned malloc across platforms
+void* aligned_buf_alloc(size_t align, size_t size) {
+    size_t actualAlign = std::max(align, sizeof(void*));
+#ifdef _WIN32
+    void* res = _aligned_malloc(size, actualAlign);
+    if (!res) {
+        abort();
+    }
+    return res;
+#else
+    void* res;
+    if (posix_memalign(&res, actualAlign, size)) {
+        abort();
+    }
+    return res;
+#endif
+}
+
+void aligned_buf_free(void* buf) {
+#ifdef _WIN32
+    _aligned_free(buf);
+#else
+    free(buf);
+#endif
+}
+
+} // namespace android
\ No newline at end of file
diff --git a/android-emu/android/base/AlignedBuf.h b/android-emu/android/base/AlignedBuf.h
new file mode 100644
index 0000000..fc74e32
--- /dev/null
+++ b/android-emu/android/base/AlignedBuf.h
@@ -0,0 +1,149 @@
+// Copyright 2018 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/Compiler.h"
+
+#include <algorithm>
+#include <atomic>
+#include <cinttypes>
+#include <cstdlib>
+#include <cstring>
+#include <type_traits>
+#include <vector>
+
+#include <stdio.h>
+
+#ifdef _WIN32
+#include <malloc.h>
+#endif
+
+namespace android {
+
+template <class T, size_t align>
+class AlignedBuf {
+public:
+    explicit AlignedBuf(size_t size) {
+        static_assert(align && ((align & (align - 1)) == 0),
+                      "AlignedBuf only supports power-of-2 aligments.");
+        resizeImpl(size);
+    }
+
+    AlignedBuf(const AlignedBuf& other) : AlignedBuf(other.mSize) {
+        if (other.mBuffer) { // could have got moved out
+            std::copy(other.mBuffer, other.mBuffer + other.mSize, mBuffer);
+        }
+    }
+
+    AlignedBuf& operator=(const AlignedBuf& other) {
+        if (this != &other) {
+            AlignedBuf tmp(other);
+            *this = std::move(tmp);
+        }
+        return *this;
+    }
+
+    AlignedBuf(AlignedBuf&& other) { *this = std::move(other); }
+
+    AlignedBuf& operator=(AlignedBuf&& other) {
+        mBuffer = other.mBuffer;
+        mSize = other.mSize;
+
+        other.mBuffer = nullptr;
+        other.mSize = 0;
+
+        return *this;
+    }
+
+    ~AlignedBuf() { if (mBuffer) freeImpl(mBuffer); } // account for getting moved out
+
+    void resize(size_t newSize) {
+#if (defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 4) || \
+        defined(__OLD_STD_VERSION__)
+        // Older g++ doesn't support std::is_trivially_copyable.
+        constexpr bool triviallyCopyable =
+                std::has_trivial_copy_constructor<T>::value;
+#else
+        constexpr bool triviallyCopyable = std::is_trivially_copyable<T>::value;
+#endif
+        static_assert(triviallyCopyable,
+                      "AlignedBuf can only resize trivially copyable values");
+
+        resizeImpl(newSize);
+    }
+
+    size_t size() const { return mSize; }
+
+    T* data() { return mBuffer; }
+
+    T& operator[](size_t index) { return mBuffer[index]; }
+
+    const T& operator[](size_t index) const { return mBuffer[index]; }
+
+    bool operator==(const AlignedBuf& other) const {
+        return 0 == std::memcmp(mBuffer, other.mBuffer, sizeof(T) * std::min(mSize, other.mSize));
+    }
+
+private:
+
+    void resizeImpl(size_t newSize) {
+        if (newSize) {
+            size_t pad = std::max(align, sizeof(T));
+            size_t keepSize = std::min(newSize, mSize);
+            size_t newSizeBytes = ((align - 1 + newSize * sizeof(T) + pad) / align) * align;
+
+            std::vector<T> temp(mBuffer, mBuffer + keepSize);
+            mBuffer = static_cast<T*>(reallocImpl(mBuffer, newSizeBytes));
+            std::copy(temp.data(), temp.data() + keepSize, mBuffer);
+        } else {
+            if (mBuffer) freeImpl(mBuffer);
+            mBuffer = nullptr;
+        }
+
+        mSize = newSize;
+    }
+
+    void* reallocImpl(void* oldPtr, size_t sizeBytes) {
+        if (oldPtr) { freeImpl(oldPtr); }
+        // Platform aligned malloc might not behave right
+        // if we give it an alignemnt value smaller than sizeof(void*).
+        size_t actualAlign = std::max(align, sizeof(void*));
+#ifdef _WIN32
+        return _aligned_malloc(sizeBytes, actualAlign);
+#else
+        void* res;
+        if (posix_memalign(&res, actualAlign, sizeBytes)) {
+            fprintf(stderr, "%s: failed to alloc aligned memory\n", __func__);
+            abort();
+        }
+        return res;
+#endif
+    }
+
+    void freeImpl(void* ptr) {
+#ifdef _WIN32
+        _aligned_free(ptr);
+#else
+        free(ptr);
+#endif
+
+    }
+
+    T* mBuffer = nullptr;
+    size_t mSize = 0;
+};
+
+// Convenience function for aligned malloc across platforms
+void* aligned_buf_alloc(size_t align, size_t size);
+void aligned_buf_free(void* buf);
+
+}  // namespace android
diff --git a/android-emu/android/base/Compiler.h b/android-emu/android/base/Compiler.h
new file mode 100644
index 0000000..ddfd992
--- /dev/null
+++ b/android-emu/android/base/Compiler.h
@@ -0,0 +1,39 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#pragma once
+
+// Use this inside a class declaration to ensure that the corresponding objects
+// cannot be copy-constructed or assigned. For example:
+//
+//   class Foo {
+//       ....
+//       DISALLOW_COPY_AND_ASSIGN(Foo)
+//       ....
+//   };
+//
+// Note: this macro is sometimes defined in 3rd-party libs, so let's check first
+#ifndef DISALLOW_COPY_AND_ASSIGN
+
+#define DISALLOW_COPY_AND_ASSIGN(T) \
+    T(const T& other) = delete; \
+    T& operator=(const T& other) = delete
+
+#endif
+
+#ifndef DISALLOW_COPY_ASSIGN_AND_MOVE
+
+#define DISALLOW_COPY_ASSIGN_AND_MOVE(T) \
+    DISALLOW_COPY_AND_ASSIGN(T); \
+    T(T&&) = delete; \
+    T& operator=(T&&) = delete
+
+#endif
diff --git a/android-emu/android/base/Optional.h b/android-emu/android/base/Optional.h
new file mode 100644
index 0000000..c599828
--- /dev/null
+++ b/android-emu/android/base/Optional.h
@@ -0,0 +1,544 @@
+// Copyright 2015-2016 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/TypeTraits.h"
+
+#include <log/log.h>
+
+#include <cassert>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+#include <cstddef>
+
+// Optional<T> - a template class to store an optional value of type T.
+//
+// Usage examples:
+//
+// Initialization and construction:
+//   Optional<Foo> foo;            // |foo| doesn't contain a value.
+//   Optional<Foo> foo(Foo(10));   // |foo| contains a copy-constructed value.
+//   Optional<Foo> foo2(foo);      // |foo2| contains a copy of |foo|'s value.
+//   Optional<Foo> foo3(std::move(foo2));  // Guess what?
+//
+// Assignment:
+//   Foo foo_value(0);
+//   Optional<Foo> foo;   // |foo| is empty.
+//   Optional<Foo> foo2;  // |foo2| is empty.
+//   foo2 = foo;          // |foo2| is still empty.
+//   foo = foo_value;     // set value of |foo| to a copy of |foo_value|
+//   foo = std::move(foo_value);  // move |foo_value| into |foo|.
+//   foo2 = foo;          // now |foo2| has a copy of |foo|'s value.
+//   foo = kNullopt;      // unset |foo|, it has no value.
+//
+// Checking and accessing value:
+//   if (foo) {
+//      // |foo| has a value.
+//      doStuff(*foo);      // |*foo| is the value inside |foo|.
+//      foo->callMethod();  // Same as (*foo).callMethod().
+//   } else {
+//      // |foo| is empty.
+//   }
+//
+//   foo.value()              // Same as *foo
+//   foo.valueOr(<default>)   // Return <default> is |foo| has no value.
+//
+// In-place construction:
+//
+//   Optional<Foo> foo;   // |foo| is empty.
+//   foo.emplace(20);     // |foo| now contains a value constructed as Foo(20)
+//
+//   Optional<Foo> foo(kInplace, 20);  // |foo| is initialized with a value
+//                                     // that is constructed in-place as
+//                                     // Foo(20).
+//
+//   return makeOptional<Foo>(20);     // Takes Foo constructor arguments
+//                                     // directly.
+//
+// Returning values:
+//
+//  Optional<Foo> myFunc(...) {
+//      if (someCondition) {
+//          return Foo(10);      // call Optional<Foo>(Foo&) constructor.
+//      } else {
+//          return {};           // call Optional<Foo>() constructor, which
+//                               // builds an empty value.
+//      }
+//  }
+//
+// Memory layout:
+//   Optional<Foo> is equivalent to:
+//
+//       struct {
+//           bool flag;
+//           Foo value;
+//       };
+//
+//  in terms of memory layout. This means it *doubles* the size of integral
+//  types. Also:
+//
+//  - Optional<Foo> can be constructed from anything that constructs a Foo.
+//
+//  - Same with Optional<Foo>(kInplace, Args...) where Args... matches any
+//    arguments that can be passed to a Foo constructor.
+//
+//  - Comparison operators are provided. Beware: an empty Optional<Foo>
+//    is always smaller than any Foo value.
+
+namespace android {
+namespace base {
+
+namespace details {
+
+// Base classes to reduce the number of instantiations of the Optional's
+// internal members.
+class OptionalFlagBase {
+public:
+    void setConstructed(bool constructed) { mConstructed = constructed; }
+    constexpr bool constructed() const { return mConstructed; }
+    constexpr operator bool() const { return constructed(); }
+    bool hasValue() const { return constructed(); }
+
+    constexpr OptionalFlagBase(bool constructed = false)
+        : mConstructed(constructed) {}
+
+private:
+    bool mConstructed = false;
+};
+
+template <size_t Size, size_t Align>
+class OptionalStorageBase {
+protected:
+    using StoreT = typename std::aligned_storage<Size, Align>::type;
+    StoreT mStorage = {};
+};
+
+}  // namespace details
+
+// A tag type for empty optional construction
+struct NulloptT {
+    constexpr explicit NulloptT(int) {}
+};
+
+// A tag type for inplace value construction
+struct InplaceT {
+    constexpr explicit InplaceT(int) {}
+};
+
+// Tag values for null optional and inplace construction
+constexpr NulloptT kNullopt{1};
+constexpr InplaceT kInplace{1};
+
+// Forward declaration for an early use
+template <class T>
+class Optional;
+
+// A type trait for checking if a type is an optional instantiation
+// Note: if you want to refer to the template name inside the template,
+//  you need to declare this alias outside of it - because the
+//  class name inside of the template stands for an instantiated template
+//  E.g, for template <T> class Foo if you say 'Foo' inside the class, it
+//  actually means Foo<T>;
+template <class U>
+using is_any_optional =
+        is_template_instantiation_of<typename std::decay<U>::type, Optional>;
+
+template <class T>
+class Optional
+    : private details::OptionalFlagBase,
+      private details::OptionalStorageBase<sizeof(T),
+                                           std::alignment_of<T>::value> {
+    // make sure all optionals are buddies - this is needed to implement
+    // conversion from optionals of other types
+    template <class U>
+    friend class Optional;
+
+    template <class U>
+    using self = Optional<U>;
+
+    using base_flag = details::OptionalFlagBase;
+    using base_storage =
+            details::OptionalStorageBase<sizeof(T),
+                                         std::alignment_of<T>::value>;
+
+public:
+    // std::optional will have this, so let's provide it
+    using value_type = T;
+
+    // make sure we forbid some Optional instantiations where things may get
+    // really messy
+    static_assert(!std::is_same<typename std::decay<T>::type, NulloptT>::value,
+                  "Optional of NulloptT is not allowed");
+    static_assert(!std::is_same<typename std::decay<T>::type, InplaceT>::value,
+                  "Optional of InplaceT is not allowed");
+    static_assert(!std::is_reference<T>::value,
+                  "Optional references are not allowed: use a pointer instead");
+
+    // constructors
+    constexpr Optional() {}
+    constexpr Optional(NulloptT) {}
+
+    Optional(const Optional& other) : base_flag(other.constructed()) {
+        if (this->constructed()) {
+            new (&get()) T(other.get());
+        }
+    }
+    Optional(Optional&& other) : base_flag(other.constructed()) {
+        if (this->constructed()) {
+            new (&get()) T(std::move(other.get()));
+        }
+    }
+
+    // Conversion constructor from optional of similar type
+    template <class U,
+              class = enable_if_c<!is_any_optional<U>::value &&
+                                  std::is_constructible<T, U>::value>>
+    Optional(const Optional<U>& other) : base_flag(other.constructed()) {
+        if (this->constructed()) {
+            new (&get()) T(other.get());
+        }
+    }
+
+    // Move-conversion constructor
+    template <class U,
+              class = enable_if_c<!is_any_optional<U>::value &&
+                                  std::is_constructible<T, U>::value>>
+    Optional(Optional<U>&& other) : base_flag(other.constructed()) {
+        if (this->constructed()) {
+            new (&get()) T(std::move(other.get()));
+        }
+    }
+
+    // Construction from a raw value
+    Optional(const T& value) : base_flag(true) { new (&get()) T(value); }
+    // Move construction from a raw value
+    Optional(T&& value) : base_flag(true) { new (&get()) T(std::move(value)); }
+
+    // Inplace construction from a list of |T|'s ctor arguments
+    template <class... Args>
+    Optional(InplaceT, Args&&... args) : base_flag(true) {
+        new (&get()) T(std::forward<Args>(args)...);
+    }
+
+    // Inplace construction from an initializer list passed into |T|'s ctor
+    template <class U,
+              class = enable_if<
+                      std::is_constructible<T, std::initializer_list<U>>>>
+    Optional(InplaceT, std::initializer_list<U> il) : base_flag(true) {
+        new (&get()) T(il);
+    }
+
+    // direct assignment
+    Optional& operator=(const Optional& other) {
+        if (&other == this) {
+            return *this;
+        }
+
+        if (this->constructed()) {
+            if (other.constructed()) {
+                get() = other.get();
+            } else {
+                destruct();
+                this->setConstructed(false);
+            }
+        } else {
+            if (other.constructed()) {
+                new (&get()) T(other.get());
+                this->setConstructed(true);
+            } else {
+                ;  // we're good
+            }
+        }
+        return *this;
+    }
+
+    // move assignment
+    Optional& operator=(Optional&& other) {
+        if (this->constructed()) {
+            if (other.constructed()) {
+                get() = std::move(other.get());
+            } else {
+                destruct();
+                this->setConstructed(false);
+            }
+        } else {
+            if (other.constructed()) {
+                new (&get()) T(std::move(other.get()));
+                this->setConstructed(true);
+            } else {
+                ;  // we're good
+            }
+        }
+        return *this;
+    }
+
+    // conversion assignment
+    template <class U,
+              class = enable_if_convertible<typename std::decay<U>::type, T>>
+    Optional& operator=(const Optional<U>& other) {
+        if (this->constructed()) {
+            if (other.constructed()) {
+                get() = other.get();
+            } else {
+                destruct();
+                this->setConstructed(false);
+            }
+        } else {
+            if (other.constructed()) {
+                new (&get()) T(other.get());
+                this->setConstructed(true);
+            } else {
+                ;  // we're good
+            }
+        }
+        return *this;
+    }
+
+    // conversion move assignment
+    template <class U,
+              class = enable_if_convertible<typename std::decay<U>::type, T>>
+    Optional& operator=(Optional<U>&& other) {
+        if (this->constructed()) {
+            if (other.constructed()) {
+                get() = std::move(other.get());
+            } else {
+                destruct();
+                this->setConstructed(false);
+            }
+        } else {
+            if (other.constructed()) {
+                new (&get()) T(std::move(other.get()));
+                this->setConstructed(true);
+            } else {
+                ;  // we're good
+            }
+        }
+        return *this;
+    }
+
+    // the most complicated one: forwarding constructor for anything convertible
+    // to |T|, excluding the stuff implemented above explicitly
+    template <class U,
+              class = enable_if_c<
+                      !is_any_optional<typename std::decay<U>::type>::value &&
+                      std::is_convertible<typename std::decay<U>::type,
+                                          T>::value>>
+    Optional& operator=(U&& other) {
+        if (this->constructed()) {
+            get() = std::forward<U>(other);
+        } else {
+            new (&get()) T(std::forward<U>(other));
+            this->setConstructed(true);
+        }
+        return *this;
+    }
+
+    // Adopt value checkers from the parent
+    using base_flag::operator bool;
+    using base_flag::hasValue;
+
+    T& value() {
+        if (!constructed()) {
+            ALOGE("Optional not constructed");
+            abort();
+        }
+        return get();
+    }
+    constexpr const T& value() const {
+        if (!constructed()) {
+            ALOGE("Optional not constructed");
+            abort();
+        }
+        return get();
+    }
+
+    T* ptr() {
+        return this->constructed() ? &get() : nullptr;
+    }
+    constexpr const T* ptr() const {
+        return this->constructed() ? &get() : nullptr;
+    }
+
+    // Value getter with fallback
+    template <class U = T,
+              class = enable_if_convertible<typename std::decay<U>::type, T>>
+    constexpr T valueOr(U&& defaultValue) const {
+        return this->constructed() ? get() : std::move(defaultValue);
+    }
+
+    // Pointer-like operators
+    T& operator*() {
+        if (!constructed()) {
+            ALOGE("Optional not constructed");
+            abort();
+        }
+        return get();
+    }
+    constexpr const T& operator*() const {
+        if (!constructed()) {
+            ALOGE("Optional not constructed");
+            abort();
+        }
+        return get();
+    }
+
+    T* operator->() {
+        if (!constructed()) {
+            ALOGE("Optional not constructed");
+            abort();
+        }
+        return &get();
+    }
+    constexpr const T* operator->() const {
+        if (!constructed()) {
+            ALOGE("Optional not constructed");
+            abort();
+        }
+        return &get();
+    }
+
+    ~Optional() {
+        if (this->constructed()) {
+            destruct();
+        }
+    }
+
+    void clear() {
+        if (this->constructed()) {
+            destruct();
+            this->setConstructed(false);
+        }
+    }
+
+    template <class U,
+              class = enable_if_convertible<typename std::decay<U>::type, T>>
+    void reset(U&& u) {
+        *this = std::forward<U>(u);
+    }
+
+    // In-place construction with possible destruction of the old value
+    template <class... Args>
+    void emplace(Args&&... args) {
+        if (this->constructed()) {
+            destruct();
+        }
+        new (&get()) T(std::forward<Args>(args)...);
+        this->setConstructed(true);
+    }
+
+    // In-place construction with possible destruction of the old value
+    // initializer-list version
+    template <class U,
+              class = enable_if<
+                      std::is_constructible<T, std::initializer_list<U>>>>
+    void emplace(std::initializer_list<U> il) {
+        if (this->constructed()) {
+            destruct();
+        }
+        new (&get()) T(il);
+        this->setConstructed(true);
+    }
+
+private:
+    // A helper function to convert the internal raw storage to T&
+    constexpr const T& get() const {
+        return *reinterpret_cast<const T*>(
+                reinterpret_cast<const char*>(&this->mStorage));
+    }
+
+    // Same thing, mutable
+    T& get() {
+        return const_cast<T&>(const_cast<const Optional*>(this)->get());
+    }
+
+    // Shortcut for a destructor call for the stored object
+    void destruct() { get().T::~T(); }
+};
+
+template <class T>
+Optional<typename std::decay<T>::type> makeOptional(T&& t) {
+    return Optional<typename std::decay<T>::type>(std::forward<T>(t));
+}
+
+template <class T, class... Args>
+Optional<typename std::decay<T>::type> makeOptional(Args&&... args) {
+    return Optional<typename std::decay<T>::type>(kInplace,
+                                                  std::forward<Args>(args)...);
+}
+
+template <class T>
+bool operator==(const Optional<T>& l, const Optional<T>& r) {
+    return l.hasValue() ? r.hasValue() && *l == *r : !r.hasValue();
+}
+template <class T>
+bool operator==(const Optional<T>& l, NulloptT) {
+    return !l;
+}
+template <class T>
+bool operator==(NulloptT, const Optional<T>& r) {
+    return !r;
+}
+template <class T>
+bool operator==(const Optional<T>& l, const T& r) {
+    return bool(l) && *l == r;
+}
+template <class T>
+bool operator==(const T& l, const Optional<T>& r) {
+    return bool(r) && l == *r;
+}
+
+template <class T>
+bool operator!=(const Optional<T>& l, const Optional<T>& r) {
+    return !(l == r);
+}
+template <class T>
+bool operator!=(const Optional<T>& l, NulloptT) {
+    return bool(l);
+}
+template <class T>
+bool operator!=(NulloptT, const Optional<T>& r) {
+    return bool(r);
+}
+template <class T>
+bool operator!=(const Optional<T>& l, const T& r) {
+    return !l || !(*l == r);
+}
+template <class T>
+bool operator!=(const T& l, const Optional<T>& r) {
+    return !r || !(l == *r);
+}
+
+template <class T>
+bool operator<(const Optional<T>& l, const Optional<T>& r) {
+    return !r ? false : (!l ? true : *l < *r);
+}
+template <class T>
+bool operator<(const Optional<T>&, NulloptT) {
+    return false;
+}
+template <class T>
+bool operator<(NulloptT, const Optional<T>& r) {
+    return bool(r);
+}
+template <class T>
+bool operator<(const Optional<T>& l, const T& r) {
+    return !l || *l < r;
+}
+template <class T>
+bool operator<(const T& l, const Optional<T>& r) {
+    return bool(r) && l < *r;
+}
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/Pool.cpp b/android-emu/android/base/Pool.cpp
new file mode 100644
index 0000000..6aa47b4
--- /dev/null
+++ b/android-emu/android/base/Pool.cpp
@@ -0,0 +1,440 @@
+// Copyright 2018 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/base/Pool.h"
+
+#include "android/base/AlignedBuf.h"
+
+#include <vector>
+
+#define DEBUG_POOL 0
+
+#if DEBUG_POOL
+
+#define D(fmt,...) fprintf(stderr, "%s: " fmt "\n", __func__, ##__VA_ARGS__);
+
+#else
+
+#define D(fmt,...)
+
+#endif
+
+namespace android {
+namespace base {
+
+// A Pool consists of:
+// - Heaps one for each allocation size
+// A Heap consists of:
+// - Block(s) for servicing allocation requests with actual memory backing
+// A Block consists of:
+// - A buffer that is the memory backing
+// - Chunks that correspond to usable units of the allocation size
+//
+// Block implementation:
+//
+// We want to make it fast to alloc new chunks and to free existing chunks from
+// this block, while not having to invalidate all existing pointers when
+// allocating new objects.
+// I'm p sure by now there's no way to do that withtout
+// - significant pre allocation
+// - linked list of blocks
+//
+// So that means some block chain (hehehehe, pun v much intended)
+// implementation Wherein, each block has fast allocation of chunks
+// correponding tot he desired allocation size.
+//
+// Any low overhead scheme of that kind, like slab alloc or buddy alloc, is
+// fine.  This one is based on:
+//
+// Ben Kenwright (b.kenwright@ncl.ac.uk): "Fast Efficient Fixed-Size Memory
+// Pool: No Loops and No Overhead" In COMPUTATION TOOLS 2012: The Third
+// International Conference on Computational Logics, Algebras, Programming,
+// Tools, and Benchmarking
+
+// Interval:
+// Make it easy to track all ranges involved so we know which free()
+// in which heap to use.
+// Assuming this doesn't grow too much past around 100 intervals
+// so we dont need to use fancy algorithms to key on it.
+struct Interval {
+    uintptr_t start;
+    uintptr_t end;
+};
+
+static size_t ilog2Floor(size_t n) {
+    size_t res = 0;
+    size_t test = 1;
+
+    while (test < n) {
+        test <<= 1;
+        ++res;
+    }
+
+    return res;
+}
+
+struct Block {
+    Block(size_t _chunkSize, size_t _numChunks) {
+        if (_chunkSize < sizeof(void*)) {
+            fprintf(
+                stderr,
+                "FATAL: Cannot allocate block with chunk size "
+                "less then %zu (wanted: %zu)!\n",
+                sizeof(void*),
+                _chunkSize);
+            abort();
+        }
+
+        chunkSize = _chunkSize;
+        chunkSizeLog2 = ilog2Floor(chunkSize);
+        numChunks = _numChunks;
+
+        D("chunk size %zu log2 %zu numChunks %zu",
+          chunkSize,
+          chunkSizeLog2,
+          numChunks);
+
+        sizeBytes = chunkSize * numChunks;
+
+        storage.resize(sizeBytes);
+        data = storage.data();
+
+        numFree = numChunks;
+        numAlloced = 0;
+        nextFree = (size_t*)data;
+    }
+
+    Interval getInterval() const {
+        uintptr_t start = (uintptr_t)data;
+        uintptr_t end = (uintptr_t)(data + sizeBytes);
+        return { start, end };
+    }
+
+    bool isFull() const { return numFree == 0; }
+
+    uint8_t* getPtr(size_t element) {
+        uint8_t* res =
+            data + (uintptr_t)chunkSize *
+                      (uintptr_t)element;
+        D("got %p element %zu chunkSize %zu",
+          res, element, chunkSize);
+        return res;
+    }
+
+    size_t getElement(void* ptr) {
+        uintptr_t ptrVal = (uintptr_t)ptr;
+        ptrVal -= (uintptr_t)data;
+        return (size_t)(ptrVal >> chunkSizeLog2);
+    }
+
+    void* alloc() {
+        // Lazily constructs the index to the
+        // next unallocated chunk.
+        if (numAlloced < numChunks) {
+            size_t* nextUnallocPtr =
+                (size_t*)getPtr(numAlloced);
+
+            ++numAlloced;
+            *nextUnallocPtr = numAlloced;
+        }
+
+        // Returns the next free object,
+        // if there is space remaining.
+        void* res = nullptr;
+        if (numFree) {
+
+            D("alloc new ptr @ %p\n", nextFree);
+
+            res = (void*)nextFree;
+            --numFree;
+            if (numFree) {
+                // Update nextFree to _point_ at the index
+                // of the next free chunk.
+                D("store %zu in %p as next free chunk",
+                   *nextFree,
+                   getPtr(*nextFree));
+                nextFree = (size_t*)getPtr(*nextFree);
+            } else {
+                // Signal that there are no more
+                // chunks available.
+                nextFree = nullptr;
+            }
+        }
+
+        return res;
+    }
+
+    void free(void* toFree) {
+        size_t* toFreeIndexPtr = (size_t*)toFree;
+        if (nextFree) {
+            D("freeing %p: still have other chunks available.", toFree);
+            D("nextFree: %p (end: %p)", nextFree, getPtr(numChunks));
+            D("nextFreeElt: %zu\n", getElement(nextFree));
+            // If there is a chunk available,
+            // point the just-freed chunk to that.
+            *toFreeIndexPtr = getElement(nextFree);
+        } else {
+            D("freeing free %p: no other chunks available.", toFree);
+            // If there are no chunks available,
+            // point the just-freed chunk to past the end.
+            *(size_t*)toFree = numChunks;
+        }
+        nextFree = (size_t*)toFree;
+        D("set next free to %p", nextFree);
+        ++numFree;
+    }
+
+    // To free everything, just reset back to the initial state :p
+    void freeAll() {
+        numFree = numChunks;
+        numAlloced = 0;
+        nextFree = (size_t*)data;
+    }
+
+    Block* next = nullptr; // Unused for now
+
+    size_t chunkSize = 0;
+    size_t chunkSizeLog2 = 0;
+    size_t numChunks = 0;
+    size_t sizeBytes = 0;
+
+    AlignedBuf<uint8_t, 64> storage { 0 };
+    uint8_t* data = nullptr;
+
+    size_t numFree = 0;
+    size_t numAlloced = 0;
+
+    size_t* nextFree = 0;
+};
+
+// Straight passthrough to Block for now unless
+// we find it necessary to track more than |kMaxAllocs|
+// allocs per heap.
+class Heap {
+public:
+    Heap(size_t allocSize, size_t chunksPerSize) :
+        mBlock(allocSize, chunksPerSize) {
+    }
+
+    Interval getInterval() const {
+        return mBlock.getInterval();
+    }
+
+    bool isFull() const {
+        return mBlock.isFull();
+    }
+
+    void* alloc() {
+        return mBlock.alloc();
+    }
+
+    void free(void* ptr) {
+        mBlock.free(ptr);
+    }
+
+    void freeAll() {
+        mBlock.freeAll();
+    }
+
+private:
+    // Just one block for now
+    Block mBlock;
+};
+
+static size_t leastPowerof2(size_t n) {
+    size_t res = 1;
+    while (res < n) {
+        res <<= 1;
+    }
+    return res;
+}
+
+class Pool::Impl {
+public:
+    Impl(size_t minSize,
+         size_t maxSize,
+         size_t chunksPerSize) :
+        // Need to bump up min alloc size
+        // because Blocks use free space for bookkeeping
+        // purposes.
+        mMinAllocSize(std::max(sizeof(void*), minSize)),
+        // Compute mMinAllocLog2.
+        // mMinAllocLog2 stores
+        // the number of bits to shift
+        // in order to obtain the heap index
+        // corresponding to a desired allocation size.
+        mMinAllocLog2(ilog2Floor(mMinAllocSize)),
+        mMaxFastSize(maxSize),
+        mChunksPerSize(chunksPerSize) {
+
+        size_t numHeaps =
+            1 + ilog2Floor(mMaxFastSize >> mMinAllocLog2);
+
+        for (size_t i = 0; i < numHeaps; i++) {
+
+            size_t allocSize = mMinAllocSize << i;
+
+            D("create heap for size %zu", allocSize);
+
+            Heap* newHeap = new Heap(allocSize, mChunksPerSize);
+
+            HeapInfo info = {
+                newHeap,
+                allocSize,
+                newHeap->getInterval(),
+            };
+
+            mHeapInfos.push_back(info);
+        }
+    }
+
+    ~Impl() {
+        for (auto& info : mHeapInfos) {
+            delete info.heap;
+        }
+    }
+
+    void* alloc(size_t wantedSize) {
+        if (wantedSize > mMaxFastSize) {
+            D("requested size %zu too large", wantedSize);
+            return nullptr;
+        }
+
+        size_t minAllocSizeNeeded =
+            std::max(mMinAllocSize, leastPowerof2(wantedSize));
+
+        size_t index =
+            ilog2Floor(minAllocSizeNeeded >> mMinAllocLog2);
+
+        D("wanted: %zu min serviceable: %zu heap index: %zu",
+          wantedSize, minAllocSizeNeeded, index);
+
+        auto heap = mHeapInfos[index].heap;
+
+        if (heap->isFull()) {
+            D("heap %zu is full", index);
+            return nullptr;
+        }
+
+        return heap->alloc();
+    }
+
+    bool free(void* ptr) {
+
+        D("for %p:", ptr);
+
+        uintptr_t ptrVal = (uintptr_t)ptr;
+
+        // Scan through linearly to find any matching
+        // interval. Interval information has been
+        // brought up to be stored directly in HeapInfo
+        // so this should be quite easy on the cache
+        // at least until a match is found.
+        for (auto& info : mHeapInfos) {
+            uintptr_t start = info.interval.start;
+            uintptr_t end = info.interval.end;
+
+            if (ptrVal >= start && ptrVal < end) {
+                D("found heap to free %p.", ptr)
+                info.heap->free(ptr);
+                return true;
+            }
+        }
+
+        D("%p not found in any heap.", ptr);
+        return false;
+    }
+
+    void freeAll() {
+        for (auto& info : mHeapInfos) {
+            info.heap->freeAll();
+        }
+    }
+
+private:
+    size_t mMinAllocSize;
+    size_t mMinAllocLog2;
+    size_t mMaxFastSize;
+    size_t mChunksPerSize;
+
+    // No need to get really complex if there are
+    // not that many heaps.
+    struct HeapInfo {
+        Heap* heap;
+        size_t allocSize;
+        Interval interval;
+    };
+
+    std::vector<HeapInfo> mHeapInfos;
+};
+
+Pool::Pool(size_t minSize,
+           size_t maxSize,
+           size_t mChunksPerSize) :
+    mImpl(new Pool::Impl(minSize,
+                         maxSize,
+                         mChunksPerSize)) {
+}
+
+Pool::~Pool() {
+    delete mImpl;
+
+    for (auto ptr : mFallbackPtrs) {
+        D("delete fallback ptr %p\n", ptr);
+        ::free(ptr);
+    }
+}
+
+// Fall back to normal alloc if it cannot be
+// serviced by the implementation.
+void* Pool::alloc(size_t wantedSize) {
+    void* ptr = mImpl->alloc(wantedSize);
+
+    if (ptr) return ptr;
+
+    D("Fallback to malloc");
+
+    ptr = ::malloc(wantedSize);
+
+    if (!ptr) {
+        D("Failed to service allocation for %zu bytes", wantedSize);
+        abort();
+    }
+
+    mFallbackPtrs.insert(ptr);
+
+    D("Fallback to malloc: got ptr %p", ptr);
+
+    return ptr;
+}
+
+// Fall back to normal free if it cannot be
+// serviced by the implementation.
+void Pool::free(void* ptr) {
+    if (mImpl->free(ptr)) return;
+
+    D("fallback to free for %p", ptr);
+    mFallbackPtrs.erase(ptr);
+    ::free(ptr);
+}
+
+void Pool::freeAll() {
+    mImpl->freeAll();
+    for (auto ptr : mFallbackPtrs) {
+        ::free(ptr);
+    }
+    mFallbackPtrs.clear();
+}
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/Pool.h b/android-emu/android/base/Pool.h
new file mode 100644
index 0000000..bce2cc1
--- /dev/null
+++ b/android-emu/android/base/Pool.h
@@ -0,0 +1,95 @@
+// Copyright 2018 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.
+#pragma once
+
+#include <unordered_set>
+
+#include <inttypes.h>
+#include <stddef.h>
+#include <string.h>
+
+namespace android {
+namespace base {
+
+// Class to make it easier to set up memory regions where it is fast
+// to allocate/deallocate buffers that have size within
+// the specified range.
+class Pool {
+public:
+    // minSize/maxSize: the target range of sizes for which we want to
+    // make allocations fast. the greater the range, the more space
+    // traded off.
+    // chunksPerSize: the target maximum number of live objects of
+    // each size that are expected. the higher it is, the more space
+    // traded off.
+    //
+    // Rough space cost formula:
+    // O(chunksPerSize * log2(maxSize / minSize) * maxSize)
+    Pool(size_t minSize = 8,
+         size_t maxSize = 4096,
+         size_t chunksPerSize = 256);
+
+    // All memory allocated by this pool
+    // is automatically deleted when the pool
+    // is deconstructed.
+    ~Pool();
+
+    void* alloc(size_t wantedSize);
+    void free(void* ptr);
+
+    // Convenience function to free everything currently allocated.
+    void freeAll();
+
+    // Convenience function to allocate an array
+    // of objects of type T.
+    template <class T>
+    T* allocArray(size_t count) {
+        size_t bytes = sizeof(T) * count;
+        void* res = alloc(bytes);
+        return (T*) res;
+    }
+
+    char* strDup(const char* toCopy) {
+        size_t bytes = strlen(toCopy) + 1;
+        void* res = alloc(bytes);
+        memset(res, 0x0, bytes);
+        memcpy(res, toCopy, bytes);
+        return (char*)res;
+    }
+
+    char** strDupArray(const char* const* arrayToCopy, size_t count) {
+        char** res = allocArray<char*>(count);
+
+        for (size_t i = 0; i < count; i++) {
+            res[i] = strDup(arrayToCopy[i]);
+        }
+
+        return res;
+    }
+
+    void* dupArray(const void* buf, size_t bytes) {
+        void* res = alloc(bytes);
+        memcpy(res, buf, bytes);
+        return res;
+    }
+
+private:
+    class Impl;
+    Impl* mImpl = nullptr;
+
+    std::unordered_set<void*> mFallbackPtrs;
+};
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/StringFormat.cpp b/android-emu/android/base/StringFormat.cpp
new file mode 100644
index 0000000..73a0e7a
--- /dev/null
+++ b/android-emu/android/base/StringFormat.cpp
@@ -0,0 +1,81 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#include "android/base/StringFormat.h"
+
+#include <stdio.h>
+
+namespace android {
+namespace base {
+
+std::string StringFormatRaw(const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    auto result = StringFormatWithArgs(format, args);
+    va_end(args);
+    return result;
+}
+
+std::string StringFormatWithArgs(const char* format, va_list args) {
+    std::string result;
+    StringAppendFormatWithArgs(&result, format, args);
+    return result;
+}
+
+void StringAppendFormatRaw(std::string* string, const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    StringAppendFormatWithArgs(string, format, args);
+    va_end(args);
+}
+
+void StringAppendFormatWithArgs(std::string* string,
+                                const char* format,
+                                va_list args) {
+    size_t cur_size = string->size();
+    size_t extra = 0;
+    for (;;) {
+        va_list args2;
+        va_copy(args2, args);
+        int ret = vsnprintf(&(*string)[cur_size], extra, format, args2);
+        va_end(args2);
+
+        if (ret == 0) {
+            // Nothing to do here.
+            break;
+        }
+
+        if (ret > 0) {
+            size_t ret_sz = static_cast<size_t>(ret);
+            if (extra == 0) {
+                // First pass, resize the string and try again.
+                extra = ret_sz + 1;
+                string->resize(cur_size + extra);
+                continue;
+            }
+            if (ret_sz < extra) {
+                // Second pass or later, success!
+                string->resize(cur_size + ret_sz);
+                return;
+            }
+        }
+
+        // NOTE: The MSVCRT.DLL implementation of snprintf() is broken and
+        // will return -1 in case of truncation. This code path is taken
+        // when this happens, or when |ret_sz| is equal or larger than
+        // |extra|. Grow the buffer to allow for more room, then try again.
+        extra += (extra >> 1) + 32;
+        string->resize(cur_size + extra);
+    }
+}
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/StringFormat.h b/android-emu/android/base/StringFormat.h
new file mode 100644
index 0000000..184ee5f
--- /dev/null
+++ b/android-emu/android/base/StringFormat.h
@@ -0,0 +1,80 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/StringView.h"
+
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include <stdarg.h>
+
+namespace android {
+namespace base {
+
+// Create a new string instance that contains the printf-style formatted
+// output from |format| and potentially any following arguments.
+std::string StringFormatRaw(const char* format, ...);
+
+// A variant of StringFormat() which uses a va_list to list formatting
+// parameters instead.
+std::string StringFormatWithArgs(const char* format, va_list args);
+
+// Appends a formatted string at the end of an existing string.
+// |string| is the target string instance, |format| the format string,
+// followed by any formatting parameters. This is more efficient than
+// appending the result of StringFormat(format,...) to |*string| directly.
+void StringAppendFormatRaw(std::string* string, const char* format, ...);
+
+// A variant of StringAppendFormat() that takes a va_list to list
+// formatting parameters.
+void StringAppendFormatWithArgs(std::string* string,
+                                const char* format,
+                                va_list args);
+
+// unpackFormatArg() is a set of overloaded functions needed to unpack
+// an argument of the formatting list to a POD value which can be passed
+// into the sprintf()-like C function
+
+// Anything which can be used to construct a string goes here and unpacks into
+// a const char*
+inline const char* unpackFormatArg(const std::string& str) {
+    return str.c_str();
+}
+
+// Forward all PODs as-is
+template <class T>
+constexpr T&& unpackFormatArg(T&& t,
+        typename std::enable_if<
+                    std::is_pod<typename std::decay<T>::type>::value
+                 >::type* = nullptr) {
+    return std::forward<T>(t);
+}
+
+// These templated versions of StringFormat*() allow one to pass all kinds of
+// string objects into the argument list
+template <class... Args>
+std::string StringFormat(const char* format, Args&&... args) {
+    return StringFormatRaw(format, unpackFormatArg(std::forward<Args>(args))...);
+}
+
+template <class... Args>
+void StringAppendFormat(std::string* string,
+                        const char* format,
+                        Args&&... args) {
+    StringAppendFormatRaw(string, format,
+                          unpackFormatArg(std::forward<Args>(args))...);
+}
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/StringView.h b/android-emu/android/base/StringView.h
new file mode 100644
index 0000000..f97ac5f
--- /dev/null
+++ b/android-emu/android/base/StringView.h
@@ -0,0 +1,295 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/Optional.h"
+#include "android/base/TypeTraits.h"
+
+#include <algorithm>
+#include <cstring>
+#include <string>
+
+namespace android {
+namespace base {
+
+// A StringView is a simple (address, size) pair that points to an
+// existing read-only string. It's a convenience class used to prevent
+// the creation of std::string() objects un-necessarily.
+//
+// Consider the two following functions:
+//
+//     size_t count1(const std::string& str) {
+//         size_t count = 0;
+//         for (size_t n = 0; n < str.size(); ++n) {
+//              if (str[n] == '1') {
+//                  count++;
+//              }
+//         }
+//         return count;
+//     }
+//
+//     size_t count2(const StringView& str) {
+//         size_t count = 0;
+//         for (size_t n = 0; n < str.size(); ++n) {
+//              if (str[n] == '2') {
+//                  count++;
+//              }
+//         }
+//         return count;
+//     }
+//
+// Then consider the following calls:
+//
+//       size_t n1 = count1("There is 1 one in this string!");
+//       size_t n2 = count2("I can count 2 too");
+//
+// In the first case, the compiler will silently create a temporary
+// std::string object, copy the input string into it (allocating memory in
+// the heap), call count1() and destroy the std::string upon its return.
+//
+// In the second case, the compiler will create a temporary StringView,
+// initialize it trivially before calling count2(), this results in
+// much less generated code, as well as better performance.
+//
+// Generally speaking, always use a reference or pointer to StringView
+// instead of a std::string if your function or method doesn't need to modify
+// its input.
+//
+class StringView {
+public:
+    constexpr StringView() : mString(""), mSize(0U) {}
+
+    constexpr StringView(const StringView& other) :
+        mString(other.data()), mSize(other.size()) {}
+
+    // IMPORTANT: all StringView constructors are intentionally not explict
+    // it is needed to allow seamless creation of StringView from all types
+    // of strings around - as it's intended to be a generic string wrapper
+
+    // A constexpr constructor from a constant buffer, initializing |mSize|
+    // as well. This allows one to declare a static const StringView instance
+    // and initialize it at compile time, with no runtime overhead:
+    //
+    // static constexpr StringView message = "blah";
+    //
+    template <size_t size>
+    constexpr StringView(const char (&buf)[size]) :
+        mString(buf), mSize(size - 1) {}
+
+    // Ctor for non-const arrays, AKA buffers. These usually contain some
+    // string formatted at runtime, so call strlen() instead of using the
+    // buffer size.
+    template <size_t size>
+    constexpr StringView(char (&buf)[size]) :
+        mString(buf), mSize(strlen(buf)) {}
+
+    // Constructor from a const char pointer. It has to be templated to make
+    // sure the array-based one is chosen for an array - otherwise non-templated
+    // overload always wins
+    // Note: the parameter type is a const reference to a const pointer. This
+    //   is to make this overload a poorer choice for the case of an array. For
+    //   the 'const char[]' argument both 'reference to an array' and 'pointer'
+    //   overloads are tied, so compiler can't choose without help
+    // Note2: for all constructors and set() calls, |end| must be
+    //   dereferencable. It is notrequired to be '\0', but there has to be some
+    //   data there. One may not construct a StringView passing past-the-end
+    //   iterator as |end|! StringView will try to dereference it.
+    template <class Char, class = enable_if<std::is_same<Char, char>>>
+    constexpr StringView(const Char* const & string) :
+            mString(string ? string : ""), mSize(string ? strlen(string) : 0) {}
+
+    StringView(const std::string& str) :
+        mString(str.c_str()), mSize(str.size()) {}
+
+    constexpr StringView(const char* str, size_t len)
+        : mString(str ? str : ""), mSize(len) {}
+
+    constexpr StringView(const char* begin, const char* end)
+        : mString(begin ? begin : ""), mSize(begin ? end - begin : 0) {}
+
+    constexpr StringView(std::nullptr_t) :
+            mString(""), mSize(0) {}
+
+    std::string str() const { return std::string(mString, mString + mSize); }
+    constexpr const char* data() const { return mString; }
+    constexpr size_t size() const { return mSize; }
+
+    typedef const char* iterator;
+    typedef const char* const_iterator;
+
+    constexpr const_iterator begin() const { return mString; }
+    constexpr const_iterator end() const { return mString + mSize; }
+
+    constexpr bool empty() const { return !size(); }
+    constexpr bool isNullTerminated() const { return *end() == '\0'; }
+
+    void clear() {
+        mSize = 0;
+        mString = "";
+    }
+
+    constexpr char operator[](size_t index) const {
+        return mString[index];
+    }
+
+    void set(const char* data, size_t len) {
+        mString = data ? data : "";
+        mSize = len;
+    }
+
+    void set(const char* str) {
+        mString = str ? str : "";
+        mSize = ::strlen(mString);
+    }
+
+    void set(const StringView& other) {
+        mString = other.mString;
+        mSize = other.mSize;
+    }
+
+    // Compare with another StringView.
+    int compare(const StringView& other) const;
+
+    StringView& operator=(const StringView& other) {
+        set(other);
+        return *this;
+    }
+
+    // find() first occurrence of |other| with an initial offset.
+    // Returns absolute offset (does not include |off|).
+    size_t find(StringView other, size_t off = 0) {
+        // Trivial case
+        if (!other.mSize) return 0;
+
+        size_t safeOff = std::min(off, mSize);
+
+        const char* searchStart = mString + safeOff;
+        const char* searchEnd = searchStart + mSize - safeOff;
+
+        const char* res =
+            std::search(searchStart, searchEnd,
+                        other.mString, other.mString + other.mSize);
+        if (res == searchEnd) return std::string::npos;
+        return (size_t)((uintptr_t)res - (uintptr_t)mString);
+    }
+
+    // getSubstr(); returns this string starting at the first place |other|
+    // occurs, otherwise a blank string.
+    StringView getSubstr(StringView other, size_t off = 0) {
+        size_t loc = find(other, off);
+        if (loc == std::string::npos) return StringView("");
+        return { mString + loc, end() };
+    }
+
+    // Returns substring starting at |begin| and running for |len|,
+    // or the rest of the string if |len| is std::string::npos.
+    StringView substr(size_t begin, size_t len = std::string::npos) {
+        if (len == std::string::npos) {
+            len = mSize - begin;
+        }
+        size_t safeOff = std::min(begin, mSize);
+        size_t safeLen = std::min(len, mSize - safeOff);
+        return { mString + safeOff, safeLen };
+    }
+
+    // Returns substring starting at |begin| ending at |end|,
+    // or the rest of the string if |end is std::string::npos.
+    StringView substrAbs(size_t begin, size_t end = std::string::npos) {
+        if (end == std::string::npos) {
+            end = begin + mSize;
+        }
+        return substr(begin, end - begin);
+    }
+
+    // Convert to std::string when needed.
+    operator std::string() const { return std::string(mString, mSize); }
+
+private:
+    const char* mString;
+    size_t mSize;
+};
+
+// Comparison operators. Defined as functions to allow automatic type
+// conversions with C strings and std::string objects.
+
+bool operator==(const StringView& x, const StringView& y);
+
+inline bool operator!=(const StringView& x, const StringView& y) {
+    return !(x == y);
+}
+
+inline bool operator<(const StringView& x, const StringView& y) {
+    return x.compare(y) < 0;
+}
+
+inline bool operator>=(const StringView& x, const StringView& y) {
+    return !(x < y);
+}
+
+inline bool operator >(const StringView& x, const StringView& y) {
+    return x.compare(y) > 0;
+}
+
+inline bool operator<=(const StringView& x, const StringView& y) {
+    return !(x > y);
+}
+
+// Helper to get a null-terminated const char* from a string view.
+// Only allocates if the StringView is not null terminated.
+//
+// Usage:
+//
+//      StringView myString = ...;
+//      printf("Contents: %s\n", c_str(myString));
+//
+// c_str(...) constructs a temporary object that may allocate memory if the
+// StringView is not null termianted.  The lifetime of the temporary object will
+// be until the next sequence point (typically the next semicolon).  If the
+// value needs to exist for longer than that, cache the instance.
+//
+//      StringView myString = ...;
+//      auto myNullTerminatedString = c_str(myString);
+//      functionAcceptingConstCharPointer(myNullTerminatedString);
+//
+class CStrWrapper {
+public:
+    CStrWrapper(StringView stringView) : mStringView(stringView) {}
+
+    // Returns a null-terminated char*, potentially creating a copy to add a
+    // null terminator.
+    const char* get() {
+        if (mStringView.isNullTerminated()) {
+            return mStringView.data();
+        } else {
+            // Create the std::string copy on-demand.
+            if (!mStringCopy) {
+                mStringCopy.emplace(mStringView.str());
+            }
+
+            return mStringCopy->c_str();
+        }
+    }
+
+    // Enable casting to const char*
+    operator const char*() { return get(); }
+
+private:
+    const StringView mStringView;
+    Optional<std::string> mStringCopy;
+};
+
+inline CStrWrapper c_str(StringView stringView) {
+    return CStrWrapper(stringView);
+}
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/TypeTraits.h b/android-emu/android/base/TypeTraits.h
new file mode 100644
index 0000000..9ab0060
--- /dev/null
+++ b/android-emu/android/base/TypeTraits.h
@@ -0,0 +1,173 @@
+// 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.
+
+#pragma once
+
+#include <iterator>
+#include <type_traits>
+
+namespace android {
+namespace base {
+
+namespace details {
+
+// a simple helper class for SFINAE below.
+template <class X = void>
+struct dummy {
+    using type = X;
+};
+
+}  // namespaces details
+
+// add some convenience shortcuts for an overly complex std::enable_if syntax
+
+// Use 'enable_if<Predicate,Type>' instead of
+// 'typename std::enable_if<Predicate::value,Type>::type'
+template <class Predicate, class Type = void*>
+using enable_if = typename std::enable_if<Predicate::value, Type>::type;
+
+// Use 'enable_if_c<BooleanFlag,Type>' instead of
+// 'typename std::enable_if<BooleanFlag,Type>::type'
+template <bool predicate, class Type = void*>
+using enable_if_c = typename std::enable_if<predicate, Type>::type;
+
+// Use 'enable_if_convertible<From,To,Type>' instead of
+// 'typename std::enable_if<std::is_convertible<From,To>::value, Type>::type'
+template <class From, class To, class Type = void*>
+using enable_if_convertible = enable_if<std::is_convertible<From, To>>;
+
+// -----------------------------------------------------------------------------
+// A predicate for checking if some object is callable with a specific
+// signature. Examples:
+//
+//     is_callable_as<int, void()>::value == false.
+//     is_callable_as<strcmp, void()>::value == false.
+//     is_callable_as<strcmp, int(const char*, const char*)>::value == true
+//
+template <class F, class Signature, class X = void>
+struct is_callable_as : std::false_type {};
+
+// This specialization is SFINAE-d out if template arguments can't be combined
+// into a call expression F(), or if the result of that call is not |R|
+template <class F, class R, class... Args>
+struct is_callable_as<
+        F,
+        R(Args...),
+        typename std::enable_if<
+                std::is_same<typename details::dummy<decltype(std::declval<F>()(
+                                     std::declval<Args>()...))>::type,
+                             R>::value>::type> : std::true_type {};
+
+//
+// A similar predicate to only check arguments of the function call and ignore
+// the specified return type
+//
+//  is_callable_as<strcmp, int(const char*, const char*)>::value == true
+//  is_callable_as<strcmp, void(const char*, const char*)>::value == false
+//  is_callable_with_args<strcmp, void(const char*, const char*)>::value == true
+//
+template <class F, class Signature, class X = void>
+struct is_callable_with_args : std::false_type {};
+
+template <class F, class R, class... Args>
+struct is_callable_with_args<
+        F,
+        R(Args...),
+        typename std::enable_if<
+                !std::is_same<typename details::dummy<decltype(std::declval<F>()(
+                                     std::declval<Args>()...))>::type,
+                              F>::value>::type> : std::true_type {};
+
+// -----------------------------------------------------------------------------
+// Check if a type |T| is any instantiation of a template |U|. Examples:
+//
+//    is_template_instantiation_of<int, std::vector>::value == false
+//    is_template_instantiation_of<
+//         std::list<std::vector<int>>, std::vector>::value == false
+//    is_template_instantiation_of<std::vector<int>, std::vector>::value == true
+//    is_template_instantiation_of<
+//         std::vector<std::vector<int>>, std::vector>::value == true
+//
+template <class T, template <class...> class U>
+struct is_template_instantiation_of : std::false_type {};
+
+template <template <class...> class U, class... Args>
+struct is_template_instantiation_of<U<Args...>, U> : std::true_type {};
+// -----------------------------------------------------------------------------
+
+//
+// is_range<T> - check if type |T| is a range-like type.
+//
+// It makes sure that expressions std::begin(t) and std::end(t) are well-formed
+// and those return the same type.
+//
+// Note: with expression SFINAE from C++14 is_range_helper<> could be renamed to
+//   is_range<> with no extra code. C++11 needs an extra level of enable_if<>
+//   to make it work when the type isn't a range.
+//
+
+namespace details {
+
+template <class T>
+using is_range_helper = std::is_same<
+        decltype(std::begin(
+                std::declval<typename std::add_lvalue_reference<T>::type>())),
+        decltype(std::end(
+                std::declval<typename std::add_lvalue_reference<T>::type>()))>;
+
+}  // namespace details
+
+template <class T, class = void>
+struct is_range : std::false_type {};
+
+template <class T>
+struct is_range<
+        T,
+        typename std::enable_if<details::is_range_helper<T>::value>::type>
+        : std::true_type {};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A class to incapsulate integer sequence 0, 1, ..., <num_args>
+//      Seq<int...>
+// Useful to pass function parameters in an array/tuple to call it later.
+//
+
+template <int...>
+struct Seq {};
+
+// A 'maker' class to construct Seq<int...> given only <num_args>
+//    value.
+//      MakeSeq<N, S...> works this way, e.g.
+//
+//      MakeSeq<2> inherits MakeSeq<2 - 1, 2 - 1> == MakeSeq<1, 1>
+//          MakeSeq<1, 1> : MakeSeq<1 - 1, 1 - 1, 1> == MakeSeq<0, 0, 1>
+//          MakeSeq<0, 0, 1> == MakeSeq<0, S...> and defines |type| = Seq<0, 1>
+
+template <int N, int... S>
+struct MakeSeq : MakeSeq<N - 1, N - 1, S...> {};
+
+template <int... S>
+struct MakeSeq<0, S...> {
+    using type = Seq<S...>;
+};
+
+//
+// MakeSeqT alias to quickly create Seq<...>:
+//      MakeSeqT<3> == Seq<0, 1, 2>
+template <int... S>
+using MakeSeqT = typename MakeSeq<S...>::type;
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/containers/SmallVector.h b/android-emu/android/base/containers/SmallVector.h
new file mode 100644
index 0000000..dc49a70
--- /dev/null
+++ b/android-emu/android/base/containers/SmallVector.h
@@ -0,0 +1,403 @@
+// Copyright 2016 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/TypeTraits.h"
+
+#include <algorithm>
+#include <initializer_list>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include <stddef.h>
+#include <stdlib.h>
+
+//
+// SmallVector<T>, SmallFixedVector<T, SmallSize>
+//
+// This header defines a replacement for a std::vector<> that uses small buffer
+// optimization technique - for some preset number of elements |SmallSize| it
+// stores them inside of the object, and falls back to the dynamically allocated
+// array only if one needs to add more elements.
+// This is useful for the performance-critical places where common number of
+// processed items is small, but it may still be quite large for a stack array.
+//
+// SmallFixedVector<> is the class you use to store elements, while
+// SmallVector<> is its base class that erases the small size from the type.
+//
+// NOTE: SmallVector<> cannot guarantee std::vector<>'s iterator invalidation
+//   rules for move() and swap() operations - std::vector<>s just exchange
+//   their iterators on swap() and pass the moved ones over, while SmallVector<>
+//   may leave the iterators pointing to nowhere if they were for the in-place
+//   array storage.
+//
+// Currenly only a limited subset of std::vector<>'s operations is implemented,
+// but fill free to add the ones you need.
+//
+
+namespace android {
+namespace base {
+
+//
+// Forward-declare the 'real' small vector class.
+template <class T, size_t S>
+class SmallFixedVector;
+
+//
+// SmallVector<T> - an interface for a small-buffer-optimized vector.
+// It hides the fixed size from its type, so one can use it to pass small
+// vectors around and not leak the buffer size to all callers:
+//
+//  void process(SmallVector<Foo>& data);
+//  ...
+//  ...
+//  SmallFixedVector<Foo, 100> aLittleBitOfFoos = ...;
+//  process(aLittleBitOfFoos);
+//  ...
+//  SmallFixedVector<Foo, 1000> moreFoos = ...;
+//  process(moreFoos);
+//
+template <class T>
+class SmallVector {
+    // Make them friends so SmallFixedVector is able to refer to SmallVector's
+    // protected members in static_assert()s.
+    template <class U, size_t S>
+    friend class SmallFixedVector;
+
+public:
+    // Common set of type aliases.
+    using value_type = T;
+    using iterator = T*;
+    using const_iterator = const T*;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using reference = T&;
+    using const_reference = const T&;
+    using size_type = size_t;
+
+    // It's ok to delete SmallVector<> through the base class - dtor() actually
+    // takes care of all living elements and the allocated memory.
+    ~SmallVector() { dtor(); }
+
+    // std::vector<> interface operations.
+    iterator begin() { return mBegin; }
+    const_iterator begin() const { return mBegin; }
+    const_iterator cbegin() const { return mBegin; }
+
+    iterator end() { return mEnd; }
+    const_iterator end() const { return mEnd; }
+    const_iterator cend() const { return mEnd; }
+
+    size_type size() const { return end() - begin(); }
+    size_type capacity() const { return mCapacity; }
+    bool empty() const { return begin() == end(); }
+
+    reference front() { return *begin(); }
+    const_reference front() const { return *cbegin(); }
+    reference back() { return *(end() - 1); }
+    const_reference back() const { return *(cend() - 1); }
+
+    reference operator[](size_t i) { return *(begin() + i); }
+    const_reference operator[](size_t i) const { return *(cbegin() + i); }
+
+    pointer data() { return mBegin; }
+    const_pointer data() const { return mBegin; }
+    const_pointer cdata() const { return mBegin; }
+
+    template <class... Args>
+    void emplace_back(Args&&... args) {
+        grow_for_size(size() + 1);
+        new (mEnd) T(std::forward<Args>(args)...);
+        ++mEnd;
+    }
+
+    void push_back(const T& t) { emplace_back(t); }
+    void push_back(T&& t) { emplace_back(std::move(t)); }
+
+    void pop_back() {
+        destruct(mEnd - 1, mEnd);
+        --mEnd;
+    }
+
+    void clear() {
+        destruct(begin(), end());
+        mEnd = mBegin;
+    }
+
+    void reserve(size_type newCap) {
+        if (newCap <= this->capacity()) {
+            return;
+        }
+        set_capacity(newCap);
+    }
+
+    void resize(size_type newSize) { resize_impl<true>(newSize); }
+
+    // This version of resizing doesn't initialize the newly allocated elements
+    // Useful for the cases when value-initialization is noticeably slow and
+    // one wants to directly construct or memcpy the elements into the resized
+    // place.
+    void resize_noinit(size_type newSize) { resize_impl<false>(newSize); }
+
+    // Returns if the current vector's buffer is dynamically allocated.
+    bool isAllocated() const { return this->cbegin() != smallBufferStart(); }
+
+protected:
+    // Hide the default constructor so only SmallFixedVector can be
+    // instantiated.
+    SmallVector() = default;
+
+    // Destroy all elements in the vector and free the array if it was allocated
+    // dynamically.
+    void dtor() {
+        this->destruct(this->begin(), this->end());
+        if (isAllocated()) {
+            free(this->mBegin);
+        }
+    }
+
+    // Just a convenience setter function to init all members at once.
+    void init(iterator begin, iterator end, size_type capacity) {
+        this->mBegin = begin;
+        this->mEnd = end;
+        this->mCapacity = capacity;
+    }
+
+    // An implementation of different resizing versions.
+    template <bool init>
+    void resize_impl(size_type newSize) {
+        if (newSize < this->size()) {
+            const auto newEnd = this->begin() + newSize;
+            this->destruct(newEnd, this->end());
+            this->mEnd = newEnd;
+        } else if (newSize > this->size()) {
+            grow_for_size(newSize);
+            const auto newEnd = this->begin() + newSize;
+            if (init) {
+                std::uninitialized_fill(this->end(), newEnd, T());
+            }
+            this->mEnd = newEnd;
+        }
+    }
+
+    // Templated append operation for a range of elements.
+    template <class Iter>
+    void insert_back(Iter b, Iter e) {
+        if (b == e) {
+            return;
+        }
+        const auto newSize = this->size() + (e - b);
+        grow_for_size(newSize);
+        this->mEnd = std::uninitialized_copy(b, e, this->mEnd);
+    }
+
+    // Multiplicative grow for the internal array so it can hold |newSize|
+    // elements.
+    // Doesn't change size(), only capacity().
+    void grow_for_size(size_type newSize) {
+        // Grow by 1.5x by default.
+        if (newSize > capacity()) {
+            set_capacity(std::max(newSize, capacity() + capacity() / 2));
+        }
+    }
+
+    // Sets the capacity() to be exacly |newCap|. Allocates the array
+    // dynamically, moves all elements over and (potentially) deallocates the
+    // old array.
+    // Doesn't change size(), only capacity().
+    void set_capacity(size_type newCap) {
+        // Here we can only be switching to the dynamic vector, as static one
+        // always has its capacity on the maximum.
+        const auto newBegin = (T*)malloc(sizeof(T) * newCap);
+        if (!newBegin) {
+            abort();  // what else can we do here?
+        }
+        const auto newEnd = std::uninitialized_copy(
+                std::make_move_iterator(this->begin()),
+                std::make_move_iterator(this->end()), newBegin);
+        dtor();
+        this->mBegin = newBegin;
+        this->mEnd = newEnd;
+        this->mCapacity = newCap;
+    }
+
+    // A convenience function to call destructor for a range of elements.
+    static void destruct(T* b, T* e) {
+        if (!std::is_trivially_destructible<T>::value) {
+            for (; b != e; ++b) {
+                b->~T();
+            }
+        }
+    }
+
+    // By design of the class, SmallFixedVector<> will be inheriting from
+    // SmallVector<>, so its in-place storage array is going to be the very next
+    // member after the last one here.
+    // This function returns that address, and SmallFixedVector<> has a static
+    // assert to make sure it remains correct.
+    constexpr const void* smallBufferStart() const {
+        return (const void*)(&mCapacity + 1);
+    }
+
+    // Standard set of members for a vector - begin, end and capacity.
+    // These point to the currently used chunk of memory, no matter if it's a
+    // heap-allocated one or an in-place array.
+    iterator mBegin;
+    iterator mEnd;
+    size_type mCapacity;
+};
+
+// The implementation of a SmallVector with a fixed in-place size, |SmallSize|.
+template <class T, size_t SmallSize>
+class SmallFixedVector : public SmallVector<T> {
+    using base = SmallVector<T>;
+
+public:
+    // Grab these from the base class.
+    using value_type = typename base::value_type;
+    using iterator = typename base::iterator;
+    using const_iterator = typename base::const_iterator;
+    using pointer = typename base::pointer;
+    using const_pointer = typename base::const_pointer;
+    using reference = typename base::reference;
+    using const_reference = typename base::const_reference;
+    using size_type = typename base::size_type;
+
+    static constexpr size_type kSmallSize = SmallSize;
+
+    // Default constructor - set up an empty vector with capacity at full
+    // internal array size.
+    SmallFixedVector() {
+        // Make sure that the small array starts exactly where base class
+        // expects it: right after the |mCapacity|.
+
+        // We can't use a static_assert with offsetof() because in msvc, it uses
+        // reinterpret_cast.
+        // TODO: Add runtime assertion instead?
+        // https://developercommunity.visualstudio.com/content/problem/22196/static-assert-cannot-compile-constexprs-method-tha.html
+#ifndef _MSC_VER
+        static_assert(offsetof(base, mCapacity) + sizeof(base::mCapacity) ==
+                                      offsetof(SmallFixedVector, mData) &&
+                              offsetof(Data, array) == 0,
+                      "SmallFixedVector<> class layout is wrong, "
+                      "|mData| needs to follow |mCapacity|");
+#endif
+
+        init_inplace();
+    }
+
+    // Ctor from a range of iterators
+    template <class Iter>
+    SmallFixedVector(Iter b, Iter e) : SmallFixedVector() {
+        this->insert_back(b, e);
+    }
+
+    // Ctor from a range - anything that has begin and end.
+    // Note: template constructor is never a copy/move-ctor.
+    template <class Range,
+              class = enable_if_c<!std::is_same<Range, T>::value &&
+                                  is_range<Range>::value>>
+    explicit SmallFixedVector(const Range& r)
+        : SmallFixedVector(std::begin(r), std::end(r)) {}
+    template <class Range,
+              class = enable_if_c<!std::is_same<Range, T>::value &&
+                                  is_range<Range>::value>>
+    explicit SmallFixedVector(Range&& r)
+        : SmallFixedVector(std::make_move_iterator(std::begin(r)),
+                           std::make_move_iterator(std::end(r))) {}
+    template <class U, class = enable_if_convertible<U, T>>
+    SmallFixedVector(std::initializer_list<U> list)
+        : SmallFixedVector(std::begin(list), std::end(list)) {}
+
+    SmallFixedVector(const SmallFixedVector& other)
+        : SmallFixedVector(other.begin(), other.end()) {}
+
+    SmallFixedVector(SmallFixedVector&& other) {
+        if (other.isAllocated()) {
+            // Just steal the allocated memory from the |other|.
+            this->mBegin = other.mBegin;
+            this->mEnd = other.mEnd;
+            this->mCapacity = other.mCapacity;
+            other.init_inplace();
+        } else {
+            // Have to move individual elements.
+            this->mBegin = mData.array;
+            this->mEnd = std::uninitialized_copy(
+                    std::make_move_iterator(other.begin()),
+                    std::make_move_iterator(other.end()), this->begin());
+            this->mCapacity = kSmallSize;
+        }
+    }
+
+    SmallFixedVector& operator=(const SmallFixedVector& other) {
+        if (&other != this) {
+            this->clear();
+            this->insert_back(other.begin(), other.end());
+        }
+        return *this;
+    }
+
+    SmallFixedVector& operator=(SmallFixedVector&& other) {
+        if (other.isAllocated()) {
+            // Steal it and we're done.
+            this->dtor();
+            this->mBegin = other.mBegin;
+            this->mEnd = other.mEnd;
+            this->mCapacity = other.mCapacity;
+            other.init_inplace();
+            return *this;
+        }
+
+        if (this->isAllocated() && this->mCapacity < other.size()) {
+            // Not enough dynamic memory, switch to in-place.
+            this->dtor();
+            init_inplace();
+        } else {
+            // This could potentially be improved by move-assigning
+            // only needed items and destroying the rest, but
+            // destroy-all+construct-all is just simpler. For PODs it actually
+            // is even faster as it's always a single memcpy().
+            this->destruct(this->begin(), this->end());
+        }
+
+        // Move the whole |other| into the pre-cleaned memory
+        const auto newEnd = std::uninitialized_copy(
+                std::make_move_iterator(other.begin()),
+                std::make_move_iterator(other.end()), this->mBegin);
+        this->mEnd = newEnd;
+        // |other| is valid as-is.
+        return *this;
+    }
+
+    // Make sure we don't end up trying to move from an interface - it's just
+    // inefficient with the current code.
+    SmallFixedVector(base&& other) = delete;
+    SmallFixedVector& operator=(base&& other) = delete;
+
+private:
+    // A shortcut for initialization for in-place storage.
+    void init_inplace() { this->init(mData.array, mData.array, kSmallSize); }
+
+    // A union with empty constructor and destructor makes sure that the array
+    // elements are not default-constructed in ctor and not destructed in dtor:
+    // the class needs to be able manage their lifetime more precisely.
+    union Data {
+        alignas(size_type) T array[kSmallSize];
+
+        Data() {}
+        ~Data() {}
+    } mData;
+};
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/files/MemStream.cpp b/android-emu/android/base/files/MemStream.cpp
new file mode 100644
index 0000000..4f8291f
--- /dev/null
+++ b/android-emu/android/base/files/MemStream.cpp
@@ -0,0 +1,62 @@
+// Copyright 2015 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#include "android/base/files/MemStream.h"
+
+#include "android/base/files/StreamSerializing.h"
+
+#include <algorithm>
+#include <utility>
+
+namespace android {
+namespace base {
+
+MemStream::MemStream(int reserveSize) {
+    mData.reserve(reserveSize);
+}
+
+MemStream::MemStream(Buffer&& data) : mData(std::move(data)) {}
+
+ssize_t MemStream::read(void* buffer, size_t size) {
+    const auto sizeToRead = std::min<int>(size, readSize());
+    memcpy(buffer, mData.data() + mReadPos, sizeToRead);
+    mReadPos += sizeToRead;
+    return sizeToRead;
+}
+
+ssize_t MemStream::write(const void* buffer, size_t size) {
+    mData.insert(mData.end(), (const char*)buffer, (const char*)buffer + size);
+    return size;
+}
+
+int MemStream::writtenSize() const {
+    return (int)mData.size();
+}
+
+int MemStream::readPos() const {
+    return mReadPos;
+}
+
+int MemStream::readSize() const {
+    return mData.size() - mReadPos;
+}
+
+void MemStream::save(Stream* stream) const {
+    saveBuffer(stream, mData);
+}
+
+void MemStream::load(Stream* stream) {
+    loadBuffer(stream, &mData);
+    mReadPos = 0;
+}
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/files/MemStream.h b/android-emu/android/base/files/MemStream.h
new file mode 100644
index 0000000..e256a68
--- /dev/null
+++ b/android-emu/android/base/files/MemStream.h
@@ -0,0 +1,55 @@
+// Copyright 2015 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/Compiler.h"
+#include "android/base/files/Stream.h"
+
+#include <vector>
+
+namespace android {
+namespace base {
+
+// An implementation of the Stream interface on top of a vector.
+class MemStream : public Stream {
+public:
+    using Buffer = std::vector<char>;
+
+    MemStream(int reserveSize = 512);
+    MemStream(Buffer&& data);
+
+    MemStream(MemStream&& other) = default;
+    MemStream& operator=(MemStream&& other) = default;
+
+    int writtenSize() const;
+    int readPos() const;
+    int readSize() const;
+
+    // Stream interface implementation.
+    ssize_t read(void* buffer, size_t size) override;
+    ssize_t write(const void* buffer, size_t size) override;
+
+    // Snapshot support.
+    void save(Stream* stream) const;
+    void load(Stream* stream);
+
+    const Buffer& buffer() const { return mData; }
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(MemStream);
+
+    Buffer mData;
+    int mReadPos = 0;
+};
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/files/Stream.cpp b/android-emu/android/base/files/Stream.cpp
new file mode 100644
index 0000000..dd4c9ef
--- /dev/null
+++ b/android-emu/android/base/files/Stream.cpp
@@ -0,0 +1,184 @@
+// Copyright 2015 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#include "android/base/files/Stream.h"
+
+#include <assert.h>
+#include <string.h>
+
+namespace android {
+namespace base {
+
+void Stream::putByte(uint8_t value) {
+    write(&value, 1U);
+}
+
+uint8_t Stream::getByte() {
+    uint8_t value[1] = { 0 };
+    read(value, 1U);
+    return value[0];
+}
+
+void Stream::putBe16(uint16_t value) {
+    uint8_t b[2] = { (uint8_t)(value >> 8), (uint8_t)value };
+    write(b, 2U);
+}
+
+uint16_t Stream::getBe16() {
+    uint8_t b[2] = { 0, 0 };
+    read(b, 2U);
+    return ((uint16_t)b[0] << 8) | (uint16_t)b[1];
+}
+
+void Stream::putBe32(uint32_t value) {
+    uint8_t b[4] = {
+            (uint8_t)(value >> 24),
+            (uint8_t)(value >> 16),
+            (uint8_t)(value >> 8),
+            (uint8_t)value };
+    write(b, 4U);
+}
+
+uint32_t Stream::getBe32() {
+    uint8_t b[4] = { 0, 0, 0, 0 };
+    read(b, 4U);
+    return ((uint32_t)b[0] << 24) |
+           ((uint32_t)b[1] << 16) |
+           ((uint32_t)b[2] << 8) |
+           (uint32_t)b[3];
+}
+
+void Stream::putBe64(uint64_t value) {
+    uint8_t b[8] = {
+            (uint8_t)(value >> 56),
+            (uint8_t)(value >> 48),
+            (uint8_t)(value >> 40),
+            (uint8_t)(value >> 32),
+            (uint8_t)(value >> 24),
+            (uint8_t)(value >> 16),
+            (uint8_t)(value >> 8),
+            (uint8_t)value };
+    write(b, 8U);
+}
+
+uint64_t Stream::getBe64() {
+    uint8_t b[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+    read(b, 8U);
+    return ((uint64_t)b[0] << 56) |
+           ((uint64_t)b[1] << 48) |
+           ((uint64_t)b[2] << 40) |
+           ((uint64_t)b[3] << 32) |
+           ((uint64_t)b[4] << 24) |
+           ((uint64_t)b[5] << 16) |
+           ((uint64_t)b[6] << 8) |
+           (uint64_t)b[7];
+}
+
+void Stream::putFloat(float v) {
+    union {
+        float f;
+        uint8_t bytes[sizeof(float)];
+    } u;
+    u.f = v;
+    this->write(u.bytes, sizeof(u.bytes));
+}
+
+float Stream::getFloat() {
+    union {
+        float f;
+        uint8_t bytes[sizeof(float)];
+    } u;
+    this->read(u.bytes, sizeof(u.bytes));
+    return u.f;
+}
+
+void Stream::putString(StringView str) {
+    this->putBe32(str.size());
+    this->write(str.data(), str.size());
+}
+
+void Stream::putString(const char* str) {
+    putString(StringView(str));
+}
+
+void Stream::putString(const char* str, size_t len) {
+    putString(StringView(str, len));
+}
+
+std::string Stream::getString() {
+    std::string result;
+    size_t len = this->getBe32();
+    if (len > 0) {
+        result.resize(len);
+        if (this->read(&result[0], len) != static_cast<ssize_t>(len)) {
+            result.clear();
+        }
+    }
+#ifdef _WIN32
+    else {
+        // std::string in GCC's STL still uses copy on write implementation
+        // with a single shared buffer for an empty string. Its dtor has
+        // a check for that shared buffer, and it deallocates memory only if
+        // the current string's instance address != shared empty string address
+        // Unfortunately, in Windows DLLs each DLL has its own copy of this
+        // empty string (that's just the way Windows DLLs work), so if this
+        // code creates an empty string and passes it over into another module,
+        // that module's std::string::~string() will compare address with its
+        // empty string object, find that they are different and will try to
+        // free() a static object.
+        // To mitigate it we make sure the string allocates something, so it
+        // isn't empty internally and dtor is OK to delete the storage.
+        result.reserve(1);
+    }
+#endif
+    return result;
+}
+
+void Stream::putPackedNum(uint64_t num) {
+    do {
+        auto byte = uint8_t(num & 0x7f);
+        num >>= 7;
+        if (num) {
+            byte |= 0x80;
+        }
+        putByte(byte);
+    } while (num != 0);
+}
+
+uint64_t Stream::getPackedNum() {
+    uint64_t res = 0;
+    uint8_t byte;
+    int i = 0;
+    do {
+        byte = getByte();
+        res |= uint64_t(byte & 0x7f) << (i++ * 7);
+    } while (byte & 0x80 && i < 10);
+    return res;
+}
+
+void Stream::putPackedSignedNum(int64_t num) {
+    if (num >= 0) {
+        assert((uint64_t(num) & (1ULL << 63)) == 0);
+        putPackedNum(uint64_t(num) << 1);
+    } else {
+        assert((uint64_t(-num) & (1ULL << 63)) == 0);
+        putPackedNum((uint64_t(-num) << 1) | 1);
+    }
+}
+
+int64_t Stream::getPackedSignedNum() {
+    auto num = getPackedNum();
+    auto sign = num & 1;
+    return sign ? -int64_t(num >> 1) : (num >> 1);
+}
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/files/Stream.h b/android-emu/android/base/files/Stream.h
new file mode 100644
index 0000000..8e2b0a0
--- /dev/null
+++ b/android-emu/android/base/files/Stream.h
@@ -0,0 +1,109 @@
+// Copyright 2015 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/StringView.h"
+
+#include <string>
+
+#include <inttypes.h>
+#include <sys/types.h>
+
+namespace android {
+namespace base {
+
+// Abstract interface to byte streams of all kind.
+// This is mainly used to implement disk serialization.
+class Stream {
+public:
+    // Default constructor.
+    Stream() = default;
+
+    // Destructor.
+    virtual ~Stream() = default;
+
+    // Read up to |size| bytes and copy them to |buffer|. Return the number
+    // of bytes that were actually transferred, or -errno value on error.
+    virtual ssize_t read(void* buffer, size_t size) = 0;
+
+    // Write up to |size| bytes from |buffer| into the stream. Return the
+    // number of bytes that were actually transferred, or -errno value on
+    // error.
+    virtual ssize_t write(const void* buffer, size_t size) = 0;
+
+    // Write a single byte |value| into the stream. Ignore errors.
+    void putByte(uint8_t value);
+
+    // Write a 16-bit |value| as big-endian into the stream. Ignore errors.
+    void putBe16(uint16_t value);
+
+    // Write a 32-bit |value| as big-endian into the stream. Ignore errors.
+    void putBe32(uint32_t value);
+
+    // Write a 64-bit |value| as big-endian into the stream. Ignore errors.
+    void putBe64(uint64_t value);
+
+    // Read a single byte from the stream. Return 0 on error.
+    uint8_t getByte();
+
+    // Read a single big-endian 16-bit value from the stream.
+    // Return 0 on error.
+    uint16_t getBe16();
+
+    // Read a single big-endian 32-bit value from the stream.
+    // Return 0 on error.
+    uint32_t getBe32();
+
+    // Read a single big-endian 64-bit value from the stream.
+    // Return 0 on error.
+    uint64_t getBe64();
+
+    // Write a 32-bit float |value| to the stream.
+    void putFloat(float value);
+
+    // Read a single 32-bit float value from the stream.
+    float getFloat();
+
+    // Write a string |str| into the stream. Ignore errors.
+    void putString(StringView str);
+
+    // Write a 0-terminated C string |str| into the stream. Ignore error.
+    void putString(const char* str);
+
+    // Write a string |str| of |strlen| bytes into the stream.
+    // Ignore errors.
+    void putString(const char* str, size_t strlen);
+
+    // Read a string from the stream. Return a new string instance,
+    // which will be empty on error. Note that this can only be used
+    // to read strings that were written with putString().
+    std::string getString();
+
+    // Put/gen an integer number into the stream, making it use as little space
+    // there as possible.
+    // It uses a simple byte-by-byte encoding scheme, putting 7 bits of the
+    // number with the 8th bit set when there's more data to read, until the
+    // whole number is read.
+    // The compression is efficient if the number range is small, but it starts
+    // wasting space when values approach 14 bits for int16 (16K), 28 bits for
+    // int32 (268M) or 56 bits for int64 (still a lot).
+    void putPackedNum(uint64_t num);
+    uint64_t getPackedNum();
+
+    // Same thing, but encode negative numbers efficiently as well (single sign
+    // bit + packed unsigned representation)
+    void putPackedSignedNum(int64_t num);
+    int64_t getPackedSignedNum();
+};
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/files/StreamSerializing.cpp b/android-emu/android/base/files/StreamSerializing.cpp
new file mode 100644
index 0000000..2a9d77a
--- /dev/null
+++ b/android-emu/android/base/files/StreamSerializing.cpp
@@ -0,0 +1,53 @@
+// Copyright 2017 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#include "android/base/files/StreamSerializing.h"
+
+namespace android {
+namespace base {
+
+void saveStream(Stream* stream, const MemStream& memStream) {
+    memStream.save(stream);
+}
+
+void loadStream(Stream* stream, MemStream* memStream) {
+    memStream->load(stream);
+}
+
+void saveBufferRaw(Stream* stream, char* buffer, uint32_t len) {
+    stream->putBe32(len);
+    stream->write(buffer, len);
+}
+
+bool loadBufferRaw(Stream* stream, char* buffer) {
+    auto len = stream->getBe32();
+    int ret = (int)stream->read(buffer, len);
+    return ret == (int)len;
+}
+
+void saveStringArray(Stream* stream, const char* const* strings, uint32_t count) {
+    stream->putBe32(count);
+    for (uint32_t i = 0; i < count; ++i) {
+        stream->putString(strings[i]);
+    }
+}
+
+std::vector<std::string> loadStringArray(Stream* stream) {
+    uint32_t count = stream->getBe32();
+    std::vector<std::string> res;
+    for (uint32_t i = 0; i < count; ++i) {
+        res.push_back(stream->getString());
+    }
+    return res;
+}
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/files/StreamSerializing.h b/android-emu/android/base/files/StreamSerializing.h
new file mode 100644
index 0000000..8e56a6e
--- /dev/null
+++ b/android-emu/android/base/files/StreamSerializing.h
@@ -0,0 +1,114 @@
+// Copyright 2017 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/containers/SmallVector.h"
+#include "android/base/files/MemStream.h"
+#include "android/base/files/Stream.h"
+#include "android/base/TypeTraits.h"
+
+#include <string>
+#include <vector>
+
+namespace android {
+namespace base {
+
+//
+// Save/load operations for different types.
+//
+
+void saveStream(Stream* stream, const MemStream& memStream);
+void loadStream(Stream* stream, MemStream* memStream);
+
+void saveBufferRaw(Stream* stream, char* buffer, uint32_t len);
+bool loadBufferRaw(Stream* stream, char* buffer);
+
+template <class T, class = enable_if<std::is_standard_layout<T>>>
+void saveBuffer(Stream* stream, const std::vector<T>& buffer) {
+    stream->putBe32(buffer.size());
+    stream->write(buffer.data(), sizeof(T) * buffer.size());
+}
+
+template <class T, class = enable_if<std::is_standard_layout<T>>>
+bool loadBuffer(Stream* stream, std::vector<T>* buffer) {
+    auto len = stream->getBe32();
+    buffer->resize(len);
+    int ret = (int)stream->read(buffer->data(), len * sizeof(T));
+    return ret == len * sizeof(T);
+}
+
+template <class T, class = enable_if<std::is_standard_layout<T>>>
+void saveBuffer(Stream* stream, const SmallVector<T>& buffer) {
+    stream->putBe32(buffer.size());
+    stream->write(buffer.data(), sizeof(T) * buffer.size());
+}
+
+template <class T, class = enable_if<std::is_standard_layout<T>>>
+bool loadBuffer(Stream* stream, SmallVector<T>* buffer) {
+    auto len = stream->getBe32();
+    buffer->clear();
+    buffer->resize_noinit(len);
+    int ret = (int)stream->read(buffer->data(), len * sizeof(T));
+    return ret == len * sizeof(T);
+}
+
+template <class T, class SaveFunc>
+void saveBuffer(Stream* stream, const std::vector<T>& buffer, SaveFunc&& saver) {
+    stream->putBe32(buffer.size());
+    for (const auto& val : buffer) {
+        saver(stream, val);
+    }
+}
+
+template <class T>
+void saveBuffer(Stream* stream, const T* buffer, size_t numElts) {
+    stream->putBe32(numElts);
+    stream->write(buffer, sizeof(T) * numElts);
+}
+
+template <class T>
+void loadBufferPtr(Stream* stream, T* out) {
+    auto len = stream->getBe32();
+    stream->read(out, len * sizeof(T));
+}
+
+template <class T, class LoadFunc>
+void loadBuffer(Stream* stream, std::vector<T>* buffer, LoadFunc&& loader) {
+    auto len = stream->getBe32();
+    buffer->clear();
+    buffer->reserve(len);
+    for (uint32_t i = 0; i < len; i++) {
+        buffer->emplace_back(loader(stream));
+    }
+}
+
+template <class Collection, class SaveFunc>
+void saveCollection(Stream* stream, const Collection& c, SaveFunc&& saver) {
+    stream->putBe32(c.size());
+    for (const auto& val : c) {
+        saver(stream, val);
+    }
+}
+
+template <class Collection, class LoadFunc>
+void loadCollection(Stream* stream, Collection* c, LoadFunc&& loader) {
+    const int size = stream->getBe32();
+    for (int i = 0; i < size; ++i) {
+        c->emplace(loader(stream));
+    }
+}
+
+void saveStringArray(Stream* stream, const char* const* strings, uint32_t count);
+std::vector<std::string> loadStringArray(Stream* stream);
+
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/base/synchronization/AndroidLock.h b/android-emu/android/base/synchronization/AndroidLock.h
new file mode 100644
index 0000000..74877d4
--- /dev/null
+++ b/android-emu/android/base/synchronization/AndroidLock.h
@@ -0,0 +1,247 @@
+// Copyright (C) 2014 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.
+
+#pragma once
+
+#include "android/base/Compiler.h"
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#else
+#include <pthread.h>
+#endif
+
+#include <assert.h>
+
+#define AEMU_DEBUG 0
+
+#if AEMU_DEBUG
+#define AEMU_IF_DEBUG(x) x
+#else
+#define AEMU_IF_DEBUG(x)
+#endif
+
+namespace android {
+namespace base {
+namespace guest {
+
+class AutoLock;
+class AutoWriteLock;
+class AutoReadLock;
+
+// A wrapper class for mutexes only suitable for using in static context,
+// where it's OK to leak the underlying system object. Use Lock for scoped or
+// member locks.
+class StaticLock {
+public:
+    using AutoLock = android::base::guest::AutoLock;
+
+    constexpr StaticLock() = default;
+
+    // Acquire the lock.
+    void lock() {
+#ifdef _WIN32
+        ::AcquireSRWLockExclusive(&mLock);
+#else
+        ::pthread_mutex_lock(&mLock);
+#endif
+        AEMU_IF_DEBUG(mIsLocked = true;)
+    }
+
+    bool tryLock() {
+        bool ret = false;
+#ifdef _WIN32
+        ret = ::TryAcquireSRWLockExclusive(&mLock);
+#else
+        ret = ::pthread_mutex_trylock(&mLock) == 0;
+#endif
+        AEMU_IF_DEBUG(mIsLocked = ret;)
+        return ret;
+    }
+
+    AEMU_IF_DEBUG(bool isLocked() const { return mIsLocked; })
+
+    // Release the lock.
+    void unlock() {
+        AEMU_IF_DEBUG(mIsLocked = false;)
+#ifdef _WIN32
+        ::ReleaseSRWLockExclusive(&mLock);
+#else
+        ::pthread_mutex_unlock(&mLock);
+#endif
+    }
+
+protected:
+    friend class ConditionVariable;
+
+#ifdef _WIN32
+    // Benchmarks show that on Windows SRWLOCK performs a little bit better than
+    // CRITICAL_SECTION for uncontended mode and much better in case of
+    // contention.
+    SRWLOCK mLock = SRWLOCK_INIT;
+#else
+    pthread_mutex_t mLock = PTHREAD_MUTEX_INITIALIZER;
+#endif
+    // Both POSIX threads and WinAPI don't allow move (undefined behavior).
+    DISALLOW_COPY_ASSIGN_AND_MOVE(StaticLock);
+
+    AEMU_IF_DEBUG(bool mIsLocked = false;)
+};
+
+// Simple wrapper class for mutexes used in non-static context.
+class Lock : public StaticLock {
+public:
+    using StaticLock::AutoLock;
+
+    constexpr Lock() = default;
+#ifndef _WIN32
+    // The only difference is that POSIX requires a deallocation function call
+    // for its mutexes.
+    ~Lock() { ::pthread_mutex_destroy(&mLock); }
+#endif
+};
+
+class ReadWriteLock {
+public:
+    using AutoWriteLock = android::base::guest::AutoWriteLock;
+    using AutoReadLock = android::base::guest::AutoReadLock;
+
+#ifdef _WIN32
+    constexpr ReadWriteLock() = default;
+    ~ReadWriteLock() = default;
+    void lockRead() { ::AcquireSRWLockShared(&mLock); }
+    void unlockRead() { ::ReleaseSRWLockShared(&mLock); }
+    void lockWrite() { ::AcquireSRWLockExclusive(&mLock); }
+    void unlockWrite() { ::ReleaseSRWLockExclusive(&mLock); }
+
+private:
+    SRWLOCK mLock = SRWLOCK_INIT;
+#else   // !_WIN32
+    ReadWriteLock() { ::pthread_rwlock_init(&mLock, NULL); }
+    ~ReadWriteLock() { ::pthread_rwlock_destroy(&mLock); }
+    void lockRead() { ::pthread_rwlock_rdlock(&mLock); }
+    void unlockRead() { ::pthread_rwlock_unlock(&mLock); }
+    void lockWrite() { ::pthread_rwlock_wrlock(&mLock); }
+    void unlockWrite() { ::pthread_rwlock_unlock(&mLock); }
+
+private:
+    pthread_rwlock_t mLock;
+#endif  // !_WIN32
+
+    friend class ConditionVariable;
+    DISALLOW_COPY_ASSIGN_AND_MOVE(ReadWriteLock);
+};
+
+// Helper class to lock / unlock a mutex automatically on scope
+// entry and exit.
+// NB: not thread-safe (as opposed to the Lock class)
+class AutoLock {
+public:
+    AutoLock(StaticLock& lock) : mLock(lock) { mLock.lock(); }
+
+    AutoLock(AutoLock&& other) : mLock(other.mLock), mLocked(other.mLocked) {
+        other.mLocked = false;
+    }
+
+    void lock() {
+        assert(!mLocked);
+        mLock.lock();
+        mLocked = true;
+    }
+
+    void unlock() {
+        assert(mLocked);
+        mLock.unlock();
+        mLocked = false;
+    }
+
+    bool isLocked() const { return mLocked; }
+
+    ~AutoLock() {
+        if (mLocked) {
+            mLock.unlock();
+        }
+    }
+
+private:
+    StaticLock& mLock;
+    bool mLocked = true;
+
+    friend class ConditionVariable;
+    // Don't allow move because this class has a non-movable object.
+    DISALLOW_COPY_AND_ASSIGN(AutoLock);
+};
+
+class AutoWriteLock {
+public:
+    AutoWriteLock(ReadWriteLock& lock) : mLock(lock) { mLock.lockWrite(); }
+
+    void lockWrite() {
+        assert(!mWriteLocked);
+        mLock.lockWrite();
+        mWriteLocked = true;
+    }
+
+    void unlockWrite() {
+        assert(mWriteLocked);
+        mLock.unlockWrite();
+        mWriteLocked = false;
+    }
+
+    ~AutoWriteLock() {
+        if (mWriteLocked) {
+            mLock.unlockWrite();
+        }
+    }
+
+private:
+    ReadWriteLock& mLock;
+    bool mWriteLocked = true;
+    // This class has a non-movable object.
+    DISALLOW_COPY_ASSIGN_AND_MOVE(AutoWriteLock);
+};
+
+class AutoReadLock {
+public:
+    AutoReadLock(ReadWriteLock& lock) : mLock(lock) { mLock.lockRead(); }
+
+    void lockRead() {
+        assert(!mReadLocked);
+        mLock.lockRead();
+        mReadLocked = true;
+    }
+
+    void unlockRead() {
+        assert(mReadLocked);
+        mLock.unlockRead();
+        mReadLocked = false;
+    }
+
+    ~AutoReadLock() {
+        if (mReadLocked) {
+            mLock.unlockRead();
+        }
+    }
+
+private:
+    ReadWriteLock& mLock;
+    bool mReadLocked = true;
+    // This class has a non-movable object.
+    DISALLOW_COPY_ASSIGN_AND_MOVE(AutoReadLock);
+};
+
+}  // namespace guest
+}  // namespace base
+}  // namespace android
diff --git a/android-emu/android/utils/compiler.h b/android-emu/android/utils/compiler.h
new file mode 100644
index 0000000..0d72fee
--- /dev/null
+++ b/android-emu/android/utils/compiler.h
@@ -0,0 +1,29 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#ifdef __cplusplus
+#define ANDROID_BEGIN_HEADER extern "C" {
+#define ANDROID_END_HEADER   }
+#else
+#define ANDROID_BEGIN_HEADER /* nothing */
+#define ANDROID_END_HEADER  /* nothing */
+#endif
+
+// ANDROID_GCC_PREREQ(<major>,<minor>) will evaluate to true
+// iff the current version of GCC is <major>.<minor> or higher.
+#if defined(__GNUC__) && defined(__GNUC_MINOR__)
+# define ANDROID_GCC_PREREQ(maj, min) \
+         ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
+#else
+# define ANDROID_GCC_PREREQ(maj, min) 0
+#endif
diff --git a/android-emu/android/utils/debug.c b/android-emu/android/utils/debug.c
new file mode 100644
index 0000000..238bd87
--- /dev/null
+++ b/android-emu/android/utils/debug.c
@@ -0,0 +1,171 @@
+/* Copyright (C) 2007-2008 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+*/
+#include "android/utils/debug.h"
+
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+uint64_t android_verbose = 0;
+
+void
+dprint( const char*  format,  ... )
+{
+    va_list  args;
+    va_start( args, format );
+    fprintf( stdout, "emulator: ");
+    vfprintf( stdout, format, args );
+    fprintf( stdout, "\n" );
+    va_end( args );
+}
+
+
+void
+dprintn( const char*  format, ... )
+{
+    va_list  args;
+    va_start( args, format );
+    vfprintf( stdout, format, args );
+    va_end( args );
+}
+
+void
+dprintnv( const char*  format, va_list args )
+{
+    vfprintf( stdout, format, args );
+}
+
+
+void
+dwarning( const char*  format, ... )
+{
+    va_list  args;
+    va_start( args, format );
+    dprintn( "emulator: WARNING: " );
+    dprintnv( format, args );
+    dprintn( "\n" );
+    va_end( args );
+}
+
+
+void
+derror( const char*  format, ... )
+{
+    va_list  args;
+    va_start( args, format );
+    dprintn( "emulator: ERROR: " );
+    dprintnv( format, args );
+    dprintn( "\n" );
+    va_end( args );
+}
+
+void
+android_tid_function_print(
+        bool use_emulator_prefix,
+        const char* function,
+        const char* format, ... )
+{
+    int tid = syscall(SYS_gettid);
+    va_list args;
+    va_start(args, format);
+    const char* prefix = use_emulator_prefix ? "emulator: " : "";
+    if (function) {
+        printf("%stid=0x%x: %s: ", prefix, tid,
+               function);
+    } else {
+        printf("%stid=0x%x: ", prefix, tid);
+    }
+
+    vprintf(format, args);
+    printf("\n");
+    va_end(args);
+}
+
+/** STDOUT/STDERR REDIRECTION
+ **
+ ** allows you to shut temporarily shutdown stdout/stderr
+ ** this is useful to get rid of debug messages from ALSA and esd
+ ** on Linux.
+ **/
+static int    stdio_disable_count;
+static int    stdio_save_out_fd;
+static int    stdio_save_err_fd;
+
+#ifdef _WIN32
+extern void
+stdio_disable( void )
+{
+    if (++stdio_disable_count == 1) {
+        int  null_fd, out_fd, err_fd;
+        fflush(stdout);
+        out_fd = _fileno(stdout);
+        err_fd = _fileno(stderr);
+        stdio_save_out_fd = _dup(out_fd);
+        stdio_save_err_fd = _dup(err_fd);
+        null_fd = _open( "NUL", _O_WRONLY );
+        _dup2(null_fd, out_fd);
+        _dup2(null_fd, err_fd);
+        close(null_fd);
+    }
+}
+
+extern void
+stdio_enable( void )
+{
+    if (--stdio_disable_count == 0) {
+        int  out_fd, err_fd;
+        fflush(stdout);
+        out_fd = _fileno(stdout);
+        err_fd = _fileno(stderr);
+        _dup2(stdio_save_out_fd, out_fd);
+        _dup2(stdio_save_err_fd, err_fd);
+        _close(stdio_save_out_fd);
+        _close(stdio_save_err_fd);
+    }
+}
+#else
+extern void
+stdio_disable( void )
+{
+    if (++stdio_disable_count == 1) {
+        int  null_fd, out_fd, err_fd;
+        fflush(stdout);
+        out_fd = fileno(stdout);
+        err_fd = fileno(stderr);
+        stdio_save_out_fd = dup(out_fd);
+        stdio_save_err_fd = dup(err_fd);
+        null_fd = open( "/dev/null", O_WRONLY );
+        dup2(null_fd, out_fd);
+        dup2(null_fd, err_fd);
+        close(null_fd);
+    }
+}
+
+extern void
+stdio_enable( void )
+{
+    if (--stdio_disable_count == 0) {
+        int  out_fd, err_fd;
+        fflush(stdout);
+        out_fd = fileno(stdout);
+        err_fd = fileno(stderr);
+        dup2(stdio_save_out_fd, out_fd);
+        dup2(stdio_save_err_fd, err_fd);
+        close(stdio_save_out_fd);
+        close(stdio_save_err_fd);
+    }
+}
+#endif
diff --git a/android-emu/android/utils/debug.h b/android-emu/android/utils/debug.h
new file mode 100644
index 0000000..a6cdc02
--- /dev/null
+++ b/android-emu/android/utils/debug.h
@@ -0,0 +1,175 @@
+/* Copyright (C) 2007-2008 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+*/
+
+#pragma once
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "android/utils/compiler.h"
+
+ANDROID_BEGIN_HEADER
+
+#define VERBOSE_TAG_LIST                                                       \
+    _VERBOSE_TAG(init, "emulator initialization")                              \
+    _VERBOSE_TAG(console, "control console")                                   \
+    _VERBOSE_TAG(modem, "emulated GSM modem")                                  \
+    _VERBOSE_TAG(radio, "emulated GSM AT Command channel")                     \
+    _VERBOSE_TAG(keys, "key bindings & presses")                               \
+    _VERBOSE_TAG(events, "events sent to the emulator")                        \
+    _VERBOSE_TAG(slirp, "internal router/firewall")                            \
+    _VERBOSE_TAG(timezone, "host timezone detection")                          \
+    _VERBOSE_TAG(socket, "network sockets")                                    \
+    _VERBOSE_TAG(proxy, "network proxy support")                               \
+    _VERBOSE_TAG(audio, "audio sub-system")                                    \
+    _VERBOSE_TAG(audioin, "audio input backend")                               \
+    _VERBOSE_TAG(audioout, "audio output backend")                             \
+    _VERBOSE_TAG(surface, "video surface support")                             \
+    _VERBOSE_TAG(qemud, "qemud multiplexer daemon")                            \
+    _VERBOSE_TAG(gps, "emulated GPS")                                          \
+    _VERBOSE_TAG(nand_limits, "nand/flash read/write thresholding")            \
+    _VERBOSE_TAG(hw_control, "emulated power/flashlight/led/vibrator")         \
+    _VERBOSE_TAG(avd_config, "android virtual device configuration")           \
+    _VERBOSE_TAG(sensors, "emulated sensors")                                  \
+    _VERBOSE_TAG(memcheck, "memory checker")                                   \
+    _VERBOSE_TAG(camera, "camera")                                             \
+    _VERBOSE_TAG(adevice, "android device connected via port forwarding")      \
+    _VERBOSE_TAG(sensors_port, "sensors emulator connected to android device") \
+    _VERBOSE_TAG(mtport, "multi-touch emulator connected to android device")   \
+    _VERBOSE_TAG(mtscreen, "multi-touch screen emulation")                     \
+    _VERBOSE_TAG(gles, "hardware OpenGLES emulation")                          \
+    _VERBOSE_TAG(gles1emu, "emulated GLESv1 renderer")                         \
+    _VERBOSE_TAG(adbserver, "ADB server")                                      \
+    _VERBOSE_TAG(adbclient, "ADB QEMU client")                                 \
+    _VERBOSE_TAG(adb, "ADB debugger")                                          \
+    _VERBOSE_TAG(asconnector, "Asynchronous socket connector")                 \
+    _VERBOSE_TAG(asyncsocket, "Asynchronous socket")                           \
+    _VERBOSE_TAG(sdkctlsocket, "Socket tethering to SdkControl server")        \
+    _VERBOSE_TAG(updater, "Update checker")                                    \
+    _VERBOSE_TAG(metrics, "Metrics reporting")                                 \
+    _VERBOSE_TAG(rotation, "Device rotation debugging")                        \
+    _VERBOSE_TAG(goldfishsync, "Goldfish Sync Device")                         \
+    _VERBOSE_TAG(syncthreads, "HostGPU Sync Threads")                          \
+    _VERBOSE_TAG(memory, "Memory Usage Report")                                \
+    _VERBOSE_TAG(car, "Emulated car data")                                     \
+    _VERBOSE_TAG(record, "Screen recording")                                   \
+    _VERBOSE_TAG(snapshot, "Snapshots")                                        \
+    _VERBOSE_TAG(virtualscene, "Virtual scene rendering")                      \
+    _VERBOSE_TAG(automation, "Automation")                                     \
+    _VERBOSE_TAG(offworld, "Offworld")                                         \
+
+#define  _VERBOSE_TAG(x,y)  VERBOSE_##x,
+typedef enum {
+    VERBOSE_TAG_LIST
+    VERBOSE_MAX  /* do not remove */
+} VerboseTag;
+#undef  _VERBOSE_TAG
+
+extern uint64_t android_verbose;
+
+// Enable/disable verbose logs from the base/* family.
+extern void base_enable_verbose_logs();
+extern void base_disable_verbose_logs();
+
+#define  VERBOSE_ENABLE(tag)    \
+    android_verbose |= (1ULL << VERBOSE_##tag)
+
+#define  VERBOSE_DISABLE(tag)   \
+    android_verbose &= (1ULL << VERBOSE_##tag)
+
+#define  VERBOSE_CHECK(tag)    \
+    ((android_verbose & (1ULL << VERBOSE_##tag)) != 0)
+
+#define  VERBOSE_CHECK_ANY()    \
+    (android_verbose != 0)
+
+#define  VERBOSE_PRINT(tag,...)  \
+    do { if (VERBOSE_CHECK(tag)) dprint(__VA_ARGS__); } while (0)
+
+// This omits the "emulator: " prefix.
+#define  VERBOSE_DPRINT(tag,format,...)  \
+    do { if (VERBOSE_CHECK(tag)) { \
+         dprintn(format "\n", \
+                 ##__VA_ARGS__); } } while(0)
+
+#define  VERBOSE_FUNCTION_PRINT(tag,format,...)  \
+    do { if (VERBOSE_CHECK(tag)) \
+         dprintn("emulator: %s: " format "\n", \
+                 __func__, ##__VA_ARGS__); } while(0)
+
+// This omits the "emulator: " prefix.
+#define  VERBOSE_FUNCTION_DPRINT(tag,format,...)  \
+    do { if (VERBOSE_CHECK(tag)) \
+         dprintn("%s: " format "\n", \
+                 __func__, ##__VA_ARGS__); } while(0)
+
+#define  VERBOSE_TID_PRINT(tag,...)  \
+    do { if (VERBOSE_CHECK(tag)) \
+         android_tid_function_print(true, NULL, __VA_ARGS__); \
+    } while (0)
+
+// This omits the "emulator: " prefix.
+#define  VERBOSE_TID_DPRINT(tag,...)  \
+    do { if (VERBOSE_CHECK(tag)) \
+         android_tid_function_print(false, NULL, __VA_ARGS__); } \
+    while (0)
+
+#define  VERBOSE_TID_FUNCTION_PRINT(tag,...) \
+    do { if (VERBOSE_CHECK(tag)) \
+         android_tid_function_print(true, __func__, __VA_ARGS__); } \
+    while (0)
+
+// This omits the "emulator: " prefix.
+#define  VERBOSE_TID_FUNCTION_DPRINT(tag,...) \
+    do { if (VERBOSE_CHECK(tag)) \
+         android_tid_function_print(false, __func__, __VA_ARGS__); } \
+    while (0)
+
+/** DEBUG TRACE SUPPORT
+ **
+ ** Debug messages can be sent by calling these functions:
+ **
+ ** 'dprint' prints "emulator: ", the message, then appends a '\n'
+ ** 'dprintn' prints the message as is
+ ** 'dprintnv' is 'dprintn' but allows you to use a va_list argument
+ ** 'dwarning' prints "emulator: WARNING: ", then appends a '\n'
+ ** 'derror' prints "emulator: ERROR: ", then appends a '\n'
+ */
+
+extern void   dprint( const char*  format, ... );
+extern void   dprintn( const char*  format, ... );
+extern void   dprintnv( const char*  format, va_list  args );
+extern void   dwarning( const char*  format, ... );
+extern void   derror( const char*  format, ... );
+
+/** MULTITHREADED DEBUG TRACING
+ **
+ ** 'android_tid_function_print' is for tracing in multi-threaded situations.
+ ** It prints "emulator: " or not (depending on |use_emulator_prefix|),
+ ** the thread id, a function name (|function|), the message, and finally '\n'.
+ */
+extern void   android_tid_function_print(bool use_emulator_prefix,
+                                         const char* function,
+                                         const char*  format, ... );
+
+/** STDOUT/STDERR REDIRECTION
+ **
+ ** allows you to shut temporarily shutdown stdout/stderr
+ ** this is useful to get rid of debug messages from ALSA and esd
+ ** on Linux.
+ **/
+
+extern void  stdio_disable( void );
+extern void  stdio_enable( void );
+
+ANDROID_END_HEADER
diff --git a/cmake_transform.py b/cmake_transform.py
new file mode 100644
index 0000000..3e8d9c5
--- /dev/null
+++ b/cmake_transform.py
@@ -0,0 +1,190 @@
+#!/bin/python
+import argparse
+import hashlib
+import json
+import logging
+import os
+import sys
+
+
+def cleanup_json(data):
+    """Cleans up the json structure by removing empty "", and empty key value
+    pairs."""
+    if (isinstance(data, unicode)):
+        copy = data.strip()
+        return None if len(copy) == 0 else copy
+
+    if (isinstance(data, dict)):
+        copy = {}
+        for key, value in data.iteritems():
+            rem = cleanup_json(value)
+            if (rem is not None):
+                copy[key] = rem
+        return None if len(copy) == 0 else copy
+
+    if (isinstance(data, list)):
+        copy = []
+        for elem in data:
+            rem = cleanup_json(elem)
+            if (rem is not None):
+                if rem not in copy:
+                    copy.append(rem)
+
+        if len(copy) == 0:
+            return None
+        return copy
+
+
+class AttrDict(dict):
+    def __init__(self, *args, **kwargs):
+        super(AttrDict, self).__init__(*args, **kwargs)
+        self.__dict__ = self
+
+    def as_list(self, name):
+        v = self.get(name, [])
+        if (isinstance(v, list)):
+            return v
+
+        return [v]
+
+
+def remove_lib_prefix(module):
+    """Removes the lib prefix, as we are not using them in CMake."""
+    if module.startswith('lib'):
+        return module[3:]
+    else:
+        return module
+
+
+def escape(msg):
+    """Escapes the "."""
+    return '"' + msg.replace('"', '\\"') + '"'
+
+
+def header():
+    """The auto generate header."""
+    return [
+        '# This is an autogenerated file! Do not edit!',
+        '# instead run make from .../device/generic/goldfish-opengl',
+        '# which will re-generate this file.'
+    ]
+
+
+def checksum(fname):
+    """Calculates a SHA256 digest of the given file name."""
+    m = hashlib.sha256()
+    with open(fname, 'r') as mk:
+        m.update(mk.read())
+    return m.hexdigest()
+
+
+def generate_module(module):
+    """Generates a cmake module."""
+    name = remove_lib_prefix(module['module'])
+    make = header()
+    mkfile = os.path.join(module['path'], 'Android.mk')
+    sha256 = checksum(mkfile)
+    make.append(
+        'android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/%s" "%s")' % (mkfile, sha256))
+    make.append('set(%s_src %s)' % (name, ' '.join(module['src'])))
+    if module['type'] == 'SHARED_LIBRARY':
+        make.append('android_add_shared_library(%s)' % name)
+    elif module['type'] == 'STATIC_LIBRARY':
+        make.append('android_add_library(%s)' % name)
+    else:
+        raise ValueError('Unexpected module type: %s' % module['type'])
+
+    # Fix up the includes.
+    includes = ['${GOLDFISH_DEVICE_ROOT}/' + s for s in module['includes']]
+    make.append('target_include_directories(%s PRIVATE %s)' %
+                (name, ' '.join(includes)))
+
+    # filter out definitions
+    defs = [escape(d) for d in module['cflags'] if d.startswith('-D')]
+
+    #  And the remaining flags.
+    flags = [escape(d) for d in module['cflags'] if not d.startswith('-D')]
+
+    # Make sure we remove the lib prefix from all our dependencies.
+    libs = [remove_lib_prefix(l) for l in module['libs']]
+    staticlibs = [remove_lib_prefix(l) for l in
+                      module.get('staticlibs', [])
+                      if l != "libandroidemu"]
+
+    # Configure the target.
+    make.append('target_compile_definitions(%s PRIVATE %s)' %
+                (name, ' '.join(defs)))
+    make.append('target_compile_options(%s PRIVATE %s)' %
+                (name, ' '.join(flags)))
+
+    if len(staticlibs) > 0:
+        make.append('target_link_libraries(%s PRIVATE %s PRIVATE %s)' %
+                    (name, ' '.join(libs), " ".join(staticlibs)))
+    else:
+        make.append('target_link_libraries(%s PRIVATE %s)' %
+                    (name, ' '.join(libs)))
+    return make
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        description='Generates a set of cmake files'
+        'based up the js representation.'
+        'Use this to generate cmake files that can be consumed by the emulator build')
+    parser.add_argument('-i', '--input', dest='input', type=str, required=True,
+                        help='json file containing the build tree')
+    parser.add_argument('-v', '--verbose',
+                        action='store_const', dest='loglevel',
+                        const=logging.INFO, default=logging.ERROR,
+                        help='Log what is happening')
+    parser.add_argument('-o', '--output',
+                        dest='outdir', type=str, default=None,
+                        help='Output directory for create CMakefile.txt')
+    parser.add_argument('-c', '--clean', dest='output', type=str,
+                        default=None,
+                        help='Write out the cleaned up js')
+    args = parser.parse_args()
+
+    logging.basicConfig(level=args.loglevel)
+
+    with open(args.input) as data_file:
+        data = json.load(data_file)
+
+    modules = cleanup_json(data)
+
+    # Write out cleaned up json, mainly useful for debugging etc.
+    if (args.output is not None):
+        with open(args.output, 'w') as out_file:
+            out_file.write(json.dumps(modules, indent=2))
+
+    # Location --> CMakeLists.txt
+    cmake = {}
+
+    # The root, it will basically just include all the generated files.
+    root = os.path.join(args.outdir, 'CMakeLists.txt')
+    mkfile = os.path.join(args.outdir, 'Android.mk')
+    sha256 = checksum(mkfile)
+    cmake[root] = header()
+    cmake[root].append('set(GOLDFISH_DEVICE_ROOT ${CMAKE_CURRENT_SOURCE_DIR})')
+    cmake[root].append(
+        'android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/%s" "%s")' % (mkfile, sha256))
+
+    # Generate the modules.
+    for module in modules:
+        location = os.path.join(args.outdir, module['path'], 'CMakeLists.txt')
+
+        # Make sure we handle the case where we have >2 modules in the same dir.
+        if location not in cmake:
+            cmake[root].append('add_subdirectory(%s)' % module['path'])
+            cmake[location] = []
+        cmake[location].extend(generate_module(module))
+
+    # Write them to disk.
+    for (loc, cmklist) in cmake.iteritems():
+        logging.info('Writing to %s', loc)
+        with open(loc, 'w') as fn:
+            fn.write('\n'.join(cmklist))
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/common.mk b/common.mk
index c15812e..7991712 100644
--- a/common.mk
+++ b/common.mk
@@ -58,7 +58,8 @@
     $(eval include $(_EMUGL_INCLUDE_TYPE))\
     $(eval _EMUGL_INCLUDE_TYPE :=) \
     $(eval _emugl_$(_emugl_HOST)modules += $(_emugl_MODULE))\
-    $(if $(EMUGL_DEBUG),$(call emugl-dump-module))
+    $(if $(EMUGL_DEBUG),$(call emugl-dump-module)) \
+    $(if $(CMAKE_GENERATE), $(call dump-json-module))
 
 # Managing module exports and imports.
 #
diff --git a/host/include/libOpenglRender/IOStream.h b/host/include/libOpenglRender/IOStream.h
index 1d32ea1..d06440e 100644
--- a/host/include/libOpenglRender/IOStream.h
+++ b/host/include/libOpenglRender/IOStream.h
@@ -41,7 +41,7 @@
         // NOTE: m_buf is 'owned' by the child class thus we expect it to be released by it
     }
 
-    unsigned char *alloc(size_t len) {
+    virtual unsigned char *alloc(size_t len) {
 
         if (m_buf && len > m_free) {
             if (flush() < 0) {
@@ -68,7 +68,7 @@
         return ptr;
     }
 
-    int flush() {
+    virtual int flush() {
 
         if (!m_buf || m_free == m_bufsize) return 0;
 
diff --git a/json-dump.mk b/json-dump.mk
new file mode 100644
index 0000000..2e20cdf
--- /dev/null
+++ b/json-dump.mk
@@ -0,0 +1,41 @@
+JSON_DUMP :=
+
+# Older versions of GNUmake do not support actual writing to file, so we sort of do what we can
+# and write out text in chunks, escaping "
+write-to-file = \
+  $(eval _args:=) \
+  $(foreach obj,$3,$(eval _args+=$(obj))$(if $(word $2,$(_args)),@printf "%s" $(subst ",\",$(_args)) >> $1 $(EOL)$(eval _args:=))) \
+  $(if $(_args),@printf "%s" $(subst ",\", $(_args)) >> $1) \
+
+define EOL
+
+
+endef
+
+# Functions to dump build information into a JSON tree.
+# This creates a [ "", "elem1", "elem2" ]
+dump-json-list = \
+	$(eval JSON_DUMP += [ "" ) \
+	$(if $(1),\
+      $(foreach _list_item,$(strip $1),$(eval JSON_DUMP += , "$(subst ",\",$(_list_item))")) \
+	) \
+	$(eval JSON_DUMP += ] )\
+
+# This creates , "name" : ["", "e1", "e2" ] 
+dump-property-list = \
+    $(eval JSON_DUMP += , "$(1)" : ) \
+	$(call dump-json-list, $($(2)))\
+
+# Dumps the module
+dump-json-module = \
+    $(eval JSON_DUMP += , { "module" : "$(_emugl_MODULE) ")\
+    $(eval JSON_DUMP += ,  "path" : "$(LOCAL_PATH) ")\
+    $(eval JSON_DUMP += , "type" : "$(_emugl.$(_emugl_MODULE).type)")\
+	$(call dump-property-list,includes,LOCAL_C_INCLUDES) \
+	$(call dump-property-list,cflags,LOCAL_CFLAGS) \
+	$(call dump-property-list,libs,LOCAL_SHARED_LIBRARIES) \
+	$(call dump-property-list,staticlibs,LOCAL_STATIC_LIBRARIES) \
+	$(call dump-property-list,src,LOCAL_SRC_FILES) \
+    $(eval JSON_DUMP += } )\
+
+		
\ No newline at end of file
diff --git a/shared/OpenglCodecCommon/Android.mk b/shared/OpenglCodecCommon/Android.mk
index b9cf6e5..3971eae 100644
--- a/shared/OpenglCodecCommon/Android.mk
+++ b/shared/OpenglCodecCommon/Android.mk
@@ -12,14 +12,33 @@
         IndexRangeCache.cpp \
         SocketStream.cpp \
         TcpStream.cpp \
+        auto_goldfish_dma_context.cpp \
+
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+commonSources += \
+        goldfish_dma_host.cpp \
+        qemu_pipe_host.cpp \
+
+else
+
+commonSources += \
+        goldfish_dma.cpp \
+
+endif
 
 ### CodecCommon  guest ##############################################
-$(call emugl-begin-static-library,libOpenglCodecCommon)
+$(call emugl-begin-shared-library,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX))
 
 LOCAL_SRC_FILES := $(commonSources)
 
 LOCAL_CFLAGS += -DLOG_TAG=\"eglCodecCommon\"
 
 $(call emugl-export,SHARED_LIBRARIES,libcutils libutils liblog)
+
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+$(call emugl-export,SHARED_LIBRARIES,android-emu-shared)
+endif
+
 $(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
 $(call emugl-end-module)
diff --git a/shared/OpenglCodecCommon/CMakeLists.txt b/shared/OpenglCodecCommon/CMakeLists.txt
new file mode 100644
index 0000000..6f1f4ea
--- /dev/null
+++ b/shared/OpenglCodecCommon/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon/Android.mk" "b90bb271cb6f2c60c9d50bfe2a1273396e77e082d3482316f50185efdfb534c9")
+set(OpenglCodecCommon_host_src GLClientState.cpp GLESTextureUtils.cpp ChecksumCalculator.cpp GLSharedGroup.cpp glUtils.cpp IndexRangeCache.cpp SocketStream.cpp TcpStream.cpp auto_goldfish_dma_context.cpp goldfish_dma_host.cpp qemu_pipe_host.cpp)
+android_add_shared_library(OpenglCodecCommon_host)
+target_include_directories(OpenglCodecCommon_host PRIVATE ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(OpenglCodecCommon_host PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"eglCodecCommon\"")
+target_compile_options(OpenglCodecCommon_host PRIVATE "-fvisibility=default")
+target_link_libraries(OpenglCodecCommon_host PRIVATE android-emu-shared cutils utils log)
\ No newline at end of file
diff --git a/shared/OpenglCodecCommon/GLClientState.cpp b/shared/OpenglCodecCommon/GLClientState.cpp
index 7d40389..c4bf4da 100644
--- a/shared/OpenglCodecCommon/GLClientState.cpp
+++ b/shared/OpenglCodecCommon/GLClientState.cpp
@@ -1271,14 +1271,14 @@
             res_info->rb_format = queryRboFormat(props.depthAttachment_rbo);
             res_info->rb_multisamples =
                 queryRboSamples(
-                        props.colorAttachmenti_rbos[colorAttachmentIndex]);
+                        props.depthAttachment_rbo);
         } else if (props.depthAttachment_hasTexObj) {
             res_info->type = FBO_ATTACHMENT_TEXTURE;
             res_info->tex_internalformat = queryTexInternalFormat(props.depthAttachment_texture);
             res_info->tex_format = queryTexFormat(props.depthAttachment_texture);
             res_info->tex_type = queryTexType(props.depthAttachment_texture);
             res_info->tex_multisamples =
-                queryTexSamples(props.colorAttachmenti_textures[colorAttachmentIndex]);
+                queryTexSamples(props.depthAttachment_texture);
         } else {
             res_info->type = FBO_ATTACHMENT_NONE;
         }
@@ -1289,14 +1289,14 @@
             res_info->rb_format = queryRboFormat(props.stencilAttachment_rbo);
             res_info->rb_multisamples =
                 queryRboSamples(
-                        props.colorAttachmenti_rbos[colorAttachmentIndex]);
+                        props.stencilAttachment_rbo);
         } else if (props.stencilAttachment_hasTexObj) {
             res_info->type = FBO_ATTACHMENT_TEXTURE;
             res_info->tex_internalformat = queryTexInternalFormat(props.stencilAttachment_texture);
             res_info->tex_format = queryTexFormat(props.stencilAttachment_texture);
             res_info->tex_type = queryTexType(props.stencilAttachment_texture);
             res_info->tex_multisamples =
-                queryTexSamples(props.colorAttachmenti_textures[colorAttachmentIndex]);
+                queryTexSamples(props.stencilAttachment_texture);
         } else {
             res_info->type = FBO_ATTACHMENT_NONE;
         }
@@ -1307,14 +1307,14 @@
             res_info->rb_format = queryRboFormat(props.depthstencilAttachment_rbo);
             res_info->rb_multisamples =
                 queryRboSamples(
-                        props.colorAttachmenti_rbos[colorAttachmentIndex]);
+                        props.depthstencilAttachment_rbo);
         } else if (props.depthstencilAttachment_hasTexObj) {
             res_info->type = FBO_ATTACHMENT_TEXTURE;
             res_info->tex_internalformat = queryTexInternalFormat(props.depthstencilAttachment_texture);
             res_info->tex_format = queryTexFormat(props.depthstencilAttachment_texture);
             res_info->tex_type = queryTexType(props.depthstencilAttachment_texture);
             res_info->tex_multisamples =
-                queryTexSamples(props.colorAttachmenti_textures[colorAttachmentIndex]);
+                queryTexSamples(props.depthstencilAttachment_texture);
         } else {
             res_info->type = FBO_ATTACHMENT_NONE;
         }
diff --git a/shared/OpenglCodecCommon/GLSharedGroup.cpp b/shared/OpenglCodecCommon/GLSharedGroup.cpp
index 19dfe0f..e4bc889 100755
--- a/shared/OpenglCodecCommon/GLSharedGroup.cpp
+++ b/shared/OpenglCodecCommon/GLSharedGroup.cpp
@@ -16,152 +16,157 @@
 
 #include "GLSharedGroup.h"
 
-/**** KeyedVector utilities ****/
-
-template <typename T>
-static void clearObjectMap(android::DefaultKeyedVector<GLuint, T>& v) {
-    for (size_t i = 0; i < v.size(); i++)
-        delete v.valueAt(i);
-    v.clear();
-}
+#include "KeyedVectorUtils.h"
 
 /**** BufferData ****/
 
 BufferData::BufferData() : m_size(0), m_usage(0), m_mapped(false) {};
-BufferData::BufferData(GLsizeiptr size, void * data) : m_size(size), m_usage(0), m_mapped(false)
-{
+
+BufferData::BufferData(GLsizeiptr size, const void* data) :
+    m_size(size), m_usage(0), m_mapped(false) {
+
     void * buffer = NULL;
+
     if (size>0) buffer = m_fixedBuffer.alloc(size);
+
     if (data) memcpy(buffer, data, size);
 }
 
 /**** ProgramData ****/
 ProgramData::ProgramData() : m_numIndexes(0),
                              m_initialized(false),
-                             m_locShiftWAR(false)
-{
+                             m_locShiftWAR(false) {
     m_Indexes = NULL;
 }
 
-void ProgramData::initProgramData(GLuint numIndexes)
-{
+void ProgramData::initProgramData(GLuint numIndexes) {
     m_initialized = true;
     m_numIndexes = numIndexes;
-    delete[] m_Indexes;
+
+    delete [] m_Indexes;
+
     m_Indexes = new IndexInfo[numIndexes];
     m_locShiftWAR = false;
 }
 
-bool ProgramData::isInitialized()
-{
+bool ProgramData::isInitialized() {
     return m_initialized;
 }
 
-ProgramData::~ProgramData()
-{
-    delete[] m_Indexes;
+ProgramData::~ProgramData() {
+
+    delete [] m_Indexes;
+
     m_Indexes = NULL;
 }
 
-void ProgramData::setIndexInfo(GLuint index, GLint base, GLint size, GLenum type)
-{
-    if (index>=m_numIndexes)
-        return;
+void ProgramData::setIndexInfo(
+    GLuint index, GLint base, GLint size, GLenum type) {
+
+    if (index >= m_numIndexes) return;
+
     m_Indexes[index].base = base;
     m_Indexes[index].size = size;
     m_Indexes[index].type = type;
+
     if (index > 0) {
         m_Indexes[index].appBase = m_Indexes[index-1].appBase +
                                    m_Indexes[index-1].size;
-    }
-    else {
+    } else {
         m_Indexes[index].appBase = 0;
     }
+
     m_Indexes[index].hostLocsPerElement = 1;
     m_Indexes[index].flags = 0;
     m_Indexes[index].samplerValue = 0;
 }
 
-void ProgramData::setIndexFlags(GLuint index, GLuint flags)
-{
-    if (index >= m_numIndexes)
-        return;
+void ProgramData::setIndexFlags(GLuint index, GLuint flags) {
+
+    if (index >= m_numIndexes) return;
+
     m_Indexes[index].flags |= flags;
 }
 
-GLuint ProgramData::getIndexForLocation(GLint location)
-{
+GLuint ProgramData::getIndexForLocation(GLint location) {
     GLuint index = m_numIndexes;
+
     GLint minDist = -1;
-    for (GLuint i=0;i<m_numIndexes;++i)
-    {
+
+    for (GLuint i = 0; i < m_numIndexes; ++i) {
         GLint dist = location - m_Indexes[i].base;
-        if (dist >= 0 &&
-            (minDist < 0 || dist < minDist)) {
+        if (dist >= 0 && (minDist < 0 || dist < minDist)) {
             index = i;
             minDist = dist;
         }
     }
+
     return index;
 }
 
-GLenum ProgramData::getTypeForLocation(GLint location)
-{
+GLenum ProgramData::getTypeForLocation(GLint location) {
     GLuint index = getIndexForLocation(location);
-    if (index<m_numIndexes) {
+    if (index < m_numIndexes) {
         return m_Indexes[index].type;
     }
     return 0;
 }
 
-void ProgramData::setupLocationShiftWAR()
-{
+void ProgramData::setupLocationShiftWAR() {
     m_locShiftWAR = false;
-    for (GLuint i=0; i<m_numIndexes; i++) {
+    for (GLuint  i= 0; i < m_numIndexes; i++) {
         if (0 != (m_Indexes[i].base & 0xffff)) {
             return;
         }
     }
+
     // if we have one uniform at location 0, we do not need the WAR.
-    if (m_numIndexes > 1) {
-        m_locShiftWAR = true;
-    }
+    if (m_numIndexes > 1) m_locShiftWAR = true;
 }
 
-GLint ProgramData::locationWARHostToApp(GLint hostLoc, GLint arrIndex)
-{
+GLint ProgramData::locationWARHostToApp(GLint hostLoc, GLint arrIndex) {
+
     if (!m_locShiftWAR) return hostLoc;
 
     GLuint index = getIndexForLocation(hostLoc);
-    if (index<m_numIndexes) {
+
+    if (index < m_numIndexes) {
         if (arrIndex > 0) {
             m_Indexes[index].hostLocsPerElement =
-                              (hostLoc - m_Indexes[index].base) / arrIndex;
+                (hostLoc - m_Indexes[index].base) / arrIndex;
         }
         return m_Indexes[index].appBase + arrIndex;
     }
+
     return -1;
 }
 
-GLint ProgramData::locationWARAppToHost(GLint appLoc)
-{
+GLint ProgramData::locationWARAppToHost(GLint appLoc) {
+
     if (!m_locShiftWAR) return appLoc;
 
-    for(GLuint i=0; i<m_numIndexes; i++) {
-        GLint elemIndex = appLoc - m_Indexes[i].appBase;
+    for (GLuint i = 0; i < m_numIndexes; i++) {
+        GLint elemIndex =
+            appLoc - m_Indexes[i].appBase;
+
         if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) {
             return m_Indexes[i].base +
                    elemIndex * m_Indexes[i].hostLocsPerElement;
         }
     }
+
     return -1;
 }
 
-GLint ProgramData::getNextSamplerUniform(GLint index, GLint* val, GLenum* target)
-{
+GLint ProgramData::getNextSamplerUniform(
+    GLint index, GLint* val, GLenum* target) {
+
     for (GLint i = index + 1; i >= 0 && i < (GLint)m_numIndexes; i++) {
+
         if (m_Indexes[i].type == GL_SAMPLER_2D) {
+
             if (val) *val = m_Indexes[i].samplerValue;
+
             if (target) {
                 if (m_Indexes[i].flags & INDEX_FLAG_SAMPLER_EXTERNAL) {
                     *target = GL_TEXTURE_EXTERNAL_OES;
@@ -169,16 +174,21 @@
                     *target = GL_TEXTURE_2D;
                 }
             }
+
             return i;
         }
+
     }
+
     return -1;
 }
 
-bool ProgramData::setSamplerUniform(GLint appLoc, GLint val, GLenum* target)
-{
+bool ProgramData::setSamplerUniform(GLint appLoc, GLint val, GLenum* target) {
+
     for (GLuint i = 0; i < m_numIndexes; i++) {
+
         GLint elemIndex = appLoc - m_Indexes[i].appBase;
+
         if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) {
             if (m_Indexes[i].type == GL_SAMPLER_2D) {
                 m_Indexes[i].samplerValue = val;
@@ -187,53 +197,47 @@
                         *target = GL_TEXTURE_EXTERNAL_OES;
                     } else {
                         *target = GL_TEXTURE_2D;
+
                     }
                 }
                 return true;
             }
         }
     }
+
     return false;
 }
 
-bool ProgramData::attachShader(GLuint shader)
-{
+bool ProgramData::attachShader(GLuint shader) {
     size_t n = m_shaders.size();
+
     for (size_t i = 0; i < n; i++) {
         if (m_shaders[i] == shader) {
             return false;
         }
     }
-    // AKA m_shaders.push_back(), but that has an ambiguous call to insertAt()
-    // due to the default parameters. This is the desired insertAt() overload.
-    m_shaders.insertAt(shader, m_shaders.size(), 1);
+    m_shaders.push_back(shader);
     return true;
 }
 
-bool ProgramData::detachShader(GLuint shader)
-{
+bool ProgramData::detachShader(GLuint shader) {
     size_t n = m_shaders.size();
+
     for (size_t i = 0; i < n; i++) {
         if (m_shaders[i] == shader) {
-            m_shaders.removeAt(i);
+            m_shaders.erase(m_shaders.begin() + i);
             return true;
         }
     }
+
     return false;
 }
 
 /***** GLSharedGroup ****/
 
-GLSharedGroup::GLSharedGroup() :
-    m_buffers(android::DefaultKeyedVector<GLuint, BufferData*>(NULL)),
-    m_programs(android::DefaultKeyedVector<GLuint, ProgramData*>(NULL)),
-    m_shaders(android::DefaultKeyedVector<GLuint, ShaderData*>(NULL)),
-    m_shaderPrograms(android::DefaultKeyedVector<GLuint, ShaderProgramData*>(NULL))
-{
-}
+GLSharedGroup::GLSharedGroup() { }
 
-GLSharedGroup::~GLSharedGroup()
-{
+GLSharedGroup::~GLSharedGroup() {
     m_buffers.clear();
     m_programs.clear();
     clearObjectMap(m_buffers);
@@ -242,193 +246,227 @@
     clearObjectMap(m_shaderPrograms);
 }
 
-bool GLSharedGroup::isShaderOrProgramObject(GLuint obj)
-{
+bool GLSharedGroup::isShaderOrProgramObject(GLuint obj) {
+
     android::AutoMutex _lock(m_lock);
-    return ((m_shaders.valueFor(obj)!=NULL) ||
-            (m_programs.valueFor(obj)!=NULL) ||
-            (m_shaderPrograms.valueFor(m_shaderProgramIdMap[obj]) !=NULL));
+
+    return (findObjectOrDefault(m_shaders, obj) ||
+            findObjectOrDefault(m_programs, obj) ||
+            findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[obj]));
 }
 
-BufferData * GLSharedGroup::getBufferData(GLuint bufferId)
-{
+BufferData* GLSharedGroup::getBufferData(GLuint bufferId) {
+
     android::AutoMutex _lock(m_lock);
-    return m_buffers.valueFor(bufferId);
+
+    return findObjectOrDefault(m_buffers, bufferId);
 }
 
 SharedTextureDataMap* GLSharedGroup::getTextureData() {
     return &m_textureRecs;
 }
 
-void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, void * data)
-{
+void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, const void* data) {
+
     android::AutoMutex _lock(m_lock);
-    m_buffers.add(bufferId, new BufferData(size, data));
+
+    m_buffers[bufferId] = new BufferData(size, data);
 }
 
-void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, void * data)
-{
+void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, const void* data) {
+
     android::AutoMutex _lock(m_lock);
-    ssize_t idx = m_buffers.indexOfKey(bufferId);
-    if (idx >= 0) {
-        delete m_buffers.valueAt(idx);
-        m_buffers.editValueAt(idx) = new BufferData(size, data);
-    } else {
-        m_buffers.add(bufferId, new BufferData(size, data));
-    }
+
+    BufferData* currentBuffer = findObjectOrDefault(m_buffers, bufferId);
+
+    if (currentBuffer) delete currentBuffer;
+
+    m_buffers[bufferId] = new BufferData(size, data);
 }
 
 void GLSharedGroup::setBufferUsage(GLuint bufferId, GLenum usage) {
+
     android::AutoMutex _lock(m_lock);
-    ssize_t idx = m_buffers.indexOfKey(bufferId);
-    if (idx >= 0) {
-        m_buffers.editValueAt(idx)->m_usage = usage;
-    }
+
+    BufferData* data = findObjectOrDefault(m_buffers, bufferId);
+
+    if (data) data->m_usage = usage;
 }
 
 void GLSharedGroup::setBufferMapped(GLuint bufferId, bool mapped) {
-    BufferData * buf = m_buffers.valueFor(bufferId);
+    BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
     if (!buf) return;
+
     buf->m_mapped = mapped;
 }
 
 GLenum GLSharedGroup::getBufferUsage(GLuint bufferId) {
-    BufferData * buf = m_buffers.valueFor(bufferId);
+    BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
     if (!buf) return 0;
+
     return buf->m_usage;
 }
 
 bool GLSharedGroup::isBufferMapped(GLuint bufferId) {
-    BufferData * buf = m_buffers.valueFor(bufferId);
+    BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
     if (!buf) return false;
+
     return buf->m_mapped;
 }
 
-GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, void * data)
-{
-    android::AutoMutex _lock(m_lock);
-    BufferData * buf = m_buffers.valueFor(bufferId);
-    if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) return GL_INVALID_VALUE;
+GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, const void* data) {
 
-    //it's safe to update now
+    android::AutoMutex _lock(m_lock);
+
+    BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
+    if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) {
+        return GL_INVALID_VALUE;
+    }
+
     memcpy((char*)buf->m_fixedBuffer.ptr() + offset, data, size);
 
     buf->m_indexRangeCache.invalidateRange((size_t)offset, (size_t)size);
     return GL_NO_ERROR;
 }
 
-void GLSharedGroup::deleteBufferData(GLuint bufferId)
-{
+void GLSharedGroup::deleteBufferData(GLuint bufferId) {
+
     android::AutoMutex _lock(m_lock);
-    ssize_t idx = m_buffers.indexOfKey(bufferId);
-    if (idx >= 0) {
-        delete m_buffers.valueAt(idx);
-        m_buffers.removeItemsAt(idx);
+
+    BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+    if (buf) {
+        delete buf;
+        m_buffers.erase(bufferId);
     }
 }
 
-void GLSharedGroup::addProgramData(GLuint program)
-{
+void GLSharedGroup::addProgramData(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData *pData = m_programs.valueFor(program);
-    if (pData)
-    {
-        m_programs.removeItem(program);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+    if (pData) {
         delete pData;
     }
 
-    m_programs.add(program,new ProgramData());
+    m_programs[program] = new ProgramData();
 }
 
-void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes)
-{
+void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData *pData = m_programs.valueFor(program);
-    if (pData)
-    {
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+    if (pData) {
         pData->initProgramData(numIndexes);
     }
 }
 
-bool GLSharedGroup::isProgramInitialized(GLuint program)
-{
+bool GLSharedGroup::isProgramInitialized(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
-    if (pData)
-    {
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
+    if (pData) {
         return pData->isInitialized();
     }
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) {
-        return spData->programData->isInitialized();
+
+    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) {
+        return false;
     }
+
+    ShaderProgramData* shaderProgramData =
+        findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (shaderProgramData) {
+        return shaderProgramData->programData.isInitialized();
+    }
+
     return false;
 }
 
-void GLSharedGroup::deleteProgramData(GLuint program)
-{
-    android::AutoMutex _lock(m_lock);
-    ProgramData *pData = m_programs.valueFor(program);
-    if (pData) {
-        delete pData;
-    }
-    m_programs.removeItem(program);
+void GLSharedGroup::deleteProgramData(GLuint program) {
 
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) {
-        delete spData;
-    }
-    m_shaderPrograms.removeItem(m_shaderProgramIdMap[program]);
+    android::AutoMutex _lock(m_lock);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
+    if (pData) delete pData;
+
+    m_programs.erase(program);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(
+            m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (spData) delete spData;
+
+    m_shaderPrograms.erase(m_shaderProgramIdMap[program]);
     m_shaderProgramIdMap.erase(program);
 }
 
 // No such thing for separable shader programs.
-void GLSharedGroup::attachShader(GLuint program, GLuint shader)
-{
+void GLSharedGroup::attachShader(GLuint program, GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* programData = m_programs.valueFor(program);
-    ssize_t idx = m_shaders.indexOfKey(shader);
-    if (programData && idx >= 0) {
-        if (programData->attachShader(shader)) {
-            refShaderDataLocked(idx);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+    ShaderData* sData = findObjectOrDefault(m_shaders, shader);
+
+    if (pData && sData) {
+        if (pData->attachShader(shader)) {
+            refShaderDataLocked(shader);
         }
     }
 }
 
-void GLSharedGroup::detachShader(GLuint program, GLuint shader)
-{
+void GLSharedGroup::detachShader(GLuint program, GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* programData = m_programs.valueFor(program);
-    ssize_t idx = m_shaders.indexOfKey(shader);
-    if (programData && idx >= 0) {
-        if (programData->detachShader(shader)) {
-            unrefShaderDataLocked(idx);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+    ShaderData* sData = findObjectOrDefault(m_shaders, shader);
+    if (pData && sData) {
+        if (pData->detachShader(shader)) {
+            unrefShaderDataLocked(shader);
         }
     }
 }
 
 // Not needed/used for separate shader programs.
-void GLSharedGroup::setProgramIndexInfo(GLuint program, GLuint index, GLint base, GLint size, GLenum type, const char* name)
-{
-    android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
-    if (pData)
-    {
-        pData->setIndexInfo(index,base,size,type);
+void GLSharedGroup::setProgramIndexInfo(
+    GLuint program, GLuint index, GLint base,
+    GLint size, GLenum type, const char* name) {
 
+    android::AutoMutex _lock(m_lock);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
+    if (pData) {
+        pData->setIndexInfo(index,base,size,type);
         if (type == GL_SAMPLER_2D) {
             size_t n = pData->getNumShaders();
             for (size_t i = 0; i < n; i++) {
                 GLuint shaderId = pData->getShader(i);
-                ShaderData* shader = m_shaders.valueFor(shaderId);
+                ShaderData* shader = findObjectOrDefault(m_shaders, shaderId);
                 if (!shader) continue;
-                ShaderData::StringList::iterator nameIter = shader->samplerExternalNames.begin();
-                ShaderData::StringList::iterator nameEnd  = shader->samplerExternalNames.end();
+                ShaderData::StringList::iterator nameIter =
+                    shader->samplerExternalNames.begin();
+                ShaderData::StringList::iterator nameEnd =
+                    shader->samplerExternalNames.end();
                 while (nameIter != nameEnd) {
                     if (*nameIter == name) {
-                        pData->setIndexFlags(index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
+                        pData->setIndexFlags(
+                            index,
+                            ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
                         break;
                     }
                     ++nameIter;
@@ -438,221 +476,319 @@
     }
 }
 
-GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location)
-{
+GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
-    GLenum type=0;
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+    GLenum type = 0;
+
     if (pData) {
         type = pData->getTypeForLocation(location);
     }
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return type;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return type;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(
+            m_shaderPrograms, m_shaderProgramIdMap[program]);
+
     if (spData) {
-        type = spData->programData->getTypeForLocation(location);
+        type = spData->programData.getTypeForLocation(location);
     }
+
     return type;
 }
 
-bool  GLSharedGroup::isProgram(GLuint program)
-{
+bool GLSharedGroup::isProgram(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
     if (pData) return true;
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return false;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
     if (spData) return true;
+
     return false;
 }
 
-void GLSharedGroup::setupLocationShiftWAR(GLuint program)
-{
+void GLSharedGroup::setupLocationShiftWAR(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData =
+        findObjectOrDefault(m_programs, program);
+
     if (pData) pData->setupLocationShiftWAR();
 }
 
-GLint GLSharedGroup::locationWARHostToApp(GLuint program, GLint hostLoc, GLint arrIndex)
-{
+GLint GLSharedGroup::locationWARHostToApp(
+    GLuint program, GLint hostLoc, GLint arrIndex) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
     if (pData) return pData->locationWARHostToApp(hostLoc, arrIndex);
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return hostLoc;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) return spData->programData->locationWARHostToApp(hostLoc, arrIndex);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return hostLoc;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (spData) return spData->programData.locationWARHostToApp(hostLoc, arrIndex);
+
     return hostLoc;
 }
 
-GLint GLSharedGroup::locationWARAppToHost(GLuint program, GLint appLoc)
-{
+GLint GLSharedGroup::locationWARAppToHost(GLuint program, GLint appLoc) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData =
+        findObjectOrDefault(m_programs, program);
+
     if (pData) return pData->locationWARAppToHost(appLoc);
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return appLoc;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) return spData->programData->locationWARAppToHost(appLoc);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return appLoc;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(
+            m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (spData) return spData->programData.locationWARAppToHost(appLoc);
+
     return appLoc;
 }
 
-bool GLSharedGroup::needUniformLocationWAR(GLuint program)
-{
+bool GLSharedGroup::needUniformLocationWAR(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData =
+        findObjectOrDefault(m_programs, program);
+
     if (pData) return pData->needUniformLocationWAR();
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) return spData->programData->needUniformLocationWAR();
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return false;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (spData) return spData->programData.needUniformLocationWAR();
+
     return false;
 }
 
-GLint GLSharedGroup::getNextSamplerUniform(GLuint program, GLint index, GLint* val, GLenum* target) const
-{
+GLint GLSharedGroup::getNextSamplerUniform(
+    GLuint program, GLint index, GLint* val, GLenum* target) const {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
     if (pData) return pData->getNextSamplerUniform(index, val, target);
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return -1;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap.find(program)->second);
-    if (spData) return spData->programData->getNextSamplerUniform(index, val, target);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return -1;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(
+            m_shaderPrograms,
+            findObjectOrDefault(m_shaderProgramIdMap, program));
+
+    if (spData) return spData->programData.getNextSamplerUniform(index, val, target);
+
     return -1;
 }
 
-bool GLSharedGroup::setSamplerUniform(GLuint program, GLint appLoc, GLint val, GLenum* target)
-{
+bool GLSharedGroup::setSamplerUniform(
+    GLuint program, GLint appLoc, GLint val, GLenum* target) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData =
+        findObjectOrDefault(m_programs, program);
+
     if (pData) return pData->setSamplerUniform(appLoc, val, target);
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) return spData->programData->setSamplerUniform(appLoc, val, target);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return false;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (spData) return spData->programData.setSamplerUniform(appLoc, val, target);
+
     return false;
 }
 
-bool  GLSharedGroup::isShader(GLuint shader)
-{
+bool GLSharedGroup::isShader(GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
-    ShaderData* pData = m_shaders.valueFor(shader);
-    return (pData!=NULL);
+
+    ShaderData* pData = findObjectOrDefault(m_shaders, shader);
+
+    return pData != NULL;
 }
 
-bool GLSharedGroup::addShaderData(GLuint shader)
-{
+bool GLSharedGroup::addShaderData(GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
+
     ShaderData* data = new ShaderData;
+
     if (data) {
-        if (m_shaders.add(shader, data) < 0) {
-            delete data;
-            data = NULL;
-        }
+        m_shaders[shader] = data;
         data->refcount = 1;
     }
+
     return data != NULL;
 }
 
-ShaderData* GLSharedGroup::getShaderData(GLuint shader)
-{
+ShaderData* GLSharedGroup::getShaderData(GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
-    return m_shaders.valueFor(shader);
+
+    return findObjectOrDefault(m_shaders, shader);
 }
 
-void GLSharedGroup::unrefShaderData(GLuint shader)
-{
+void GLSharedGroup::unrefShaderData(GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
-    ssize_t idx = m_shaders.indexOfKey(shader);
-    if (idx >= 0) {
-        unrefShaderDataLocked(idx);
-    }
+
+    unrefShaderDataLocked(shader);
 }
 
-void GLSharedGroup::refShaderDataLocked(ssize_t shaderIdx)
-{
-    assert(shaderIdx >= 0 && shaderIdx <= m_shaders.size());
-    ShaderData* data = m_shaders.valueAt(shaderIdx);
+void GLSharedGroup::refShaderDataLocked(GLuint shaderId) {
+    ShaderData* data = findObjectOrDefault(m_shaders, shaderId);
     data->refcount++;
 }
 
-void GLSharedGroup::unrefShaderDataLocked(ssize_t shaderIdx)
-{
-    assert(shaderIdx >= 0 && shaderIdx <= m_shaders.size());
-    ShaderData* data = m_shaders.valueAt(shaderIdx);
-    if (--data->refcount == 0) {
+void GLSharedGroup::unrefShaderDataLocked(GLuint shaderId) {
+    ShaderData* data = findObjectOrDefault(m_shaders, shaderId);
+
+    if (data && --data->refcount == 0) {
+
         delete data;
-        m_shaders.removeItemsAt(shaderIdx);
+
+        m_shaders.erase(shaderId);
     }
 }
 
 uint32_t GLSharedGroup::addNewShaderProgramData() {
+
     android::AutoMutex _lock(m_lock);
+
     ShaderProgramData* data = new ShaderProgramData;
     uint32_t currId = m_shaderProgramId;
+
     ALOGD("%s: new data %p id %u", __FUNCTION__, data, currId);
-    m_shaderPrograms.add(currId, data);
+
+    m_shaderPrograms[currId] = data;
     m_shaderProgramId++;
     return currId;
 }
 
-void GLSharedGroup::associateGLShaderProgram(GLuint shaderProgramName, uint32_t shaderProgramId) {
+void GLSharedGroup::associateGLShaderProgram(
+    GLuint shaderProgramName, uint32_t shaderProgramId) {
+
     android::AutoMutex _lock(m_lock);
+
     m_shaderProgramIdMap[shaderProgramName] = shaderProgramId;
 }
 
 ShaderProgramData* GLSharedGroup::getShaderProgramDataById(uint32_t id) {
+
     android::AutoMutex _lock(m_lock);
-    ShaderProgramData* res = m_shaderPrograms.valueFor(id);
+
+    ShaderProgramData* res = findObjectOrDefault(m_shaderPrograms, id);
+
     ALOGD("%s: id=%u res=%p", __FUNCTION__, id, res);
+
     return res;
 }
 
-ShaderProgramData* GLSharedGroup::getShaderProgramData(GLuint shaderProgramName) {
+ShaderProgramData* GLSharedGroup::getShaderProgramData(
+    GLuint shaderProgramName) {
+
     android::AutoMutex _lock(m_lock);
-    return m_shaderPrograms.valueFor(m_shaderProgramIdMap[shaderProgramName]);
+
+    return findObjectOrDefault(m_shaderPrograms,
+                               m_shaderProgramIdMap[shaderProgramName]);
 }
 
 void GLSharedGroup::deleteShaderProgramDataById(uint32_t id) {
+
     android::AutoMutex _lock(m_lock);
-    ShaderProgramData* data = m_shaderPrograms.valueFor(id);
+
+    ShaderProgramData* data =
+        findObjectOrDefault(m_shaderPrograms, id);
+
     delete data;
-    m_shaderPrograms.removeItemsAt(id);
+
+    m_shaderPrograms.erase(id);
 }
 
 
 void GLSharedGroup::deleteShaderProgramData(GLuint shaderProgramName) {
+
     android::AutoMutex _lock(m_lock);
+
     uint32_t id = m_shaderProgramIdMap[shaderProgramName];
-    ShaderProgramData* data = m_shaderPrograms.valueFor(id);
+    ShaderProgramData* data = findObjectOrDefault(m_shaderPrograms, id);
+
     delete data;
-    m_shaderPrograms.removeItemsAt(id);
+
+    m_shaderPrograms.erase(id);
     m_shaderProgramIdMap.erase(shaderProgramName);
 }
 
 void GLSharedGroup::initShaderProgramData(GLuint shaderProgram, GLuint numIndices) {
     ShaderProgramData* spData = getShaderProgramData(shaderProgram);
-    spData->programData->initProgramData(numIndices);
+    spData->programData.initProgramData(numIndices);
 }
 
-void GLSharedGroup::setShaderProgramIndexInfo(GLuint shaderProgram, GLuint index, GLint base, GLint size, GLenum type, const char* name) {
+void GLSharedGroup::setShaderProgramIndexInfo(
+    GLuint shaderProgram, GLuint index, GLint base,
+    GLint size, GLenum type, const char* name) {
+
     ShaderProgramData* spData = getShaderProgramData(shaderProgram);
-    ProgramData* pData = spData->programData;
-    ShaderData* sData = spData->shaderData;
+    ProgramData& pData = spData->programData;
+    ShaderData& sData = spData->shaderData;
 
-    if (pData)
-    {
-        pData->setIndexInfo(index, base, size, type);
+    pData.setIndexInfo(index, base, size, type);
 
-        if (type == GL_SAMPLER_2D) {
-            ShaderData::StringList::iterator nameIter = sData->samplerExternalNames.begin();
-            ShaderData::StringList::iterator nameEnd  = sData->samplerExternalNames.end();
-            while (nameIter != nameEnd) {
-                if (*nameIter == name) {
-                    pData->setIndexFlags(index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
-                    break;
-                }
-                ++nameIter;
+    if (type == GL_SAMPLER_2D) {
+
+        ShaderData::StringList::iterator nameIter =
+            sData.samplerExternalNames.begin();
+        ShaderData::StringList::iterator nameEnd =
+            sData.samplerExternalNames.end();
+
+        while (nameIter != nameEnd) {
+            if (*nameIter == name) {
+                pData.setIndexFlags(
+                    index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
+                break;
             }
+            ++nameIter;
         }
     }
 }
 
 void GLSharedGroup::setupShaderProgramLocationShiftWAR(GLuint shaderProgram) {
     ShaderProgramData* spData = getShaderProgramData(shaderProgram);
-    spData->programData->setupLocationShiftWAR();
+    spData->programData.setupLocationShiftWAR();
 }
diff --git a/shared/OpenglCodecCommon/GLSharedGroup.h b/shared/OpenglCodecCommon/GLSharedGroup.h
index ca33836..9ef92ea 100755
--- a/shared/OpenglCodecCommon/GLSharedGroup.h
+++ b/shared/OpenglCodecCommon/GLSharedGroup.h
@@ -36,17 +36,15 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "ErrorLog.h"
-#include <utils/KeyedVector.h>
-#include <utils/List.h>
-#include <utils/String8.h>
 #include <utils/threads.h>
 #include "FixedBuffer.h"
+#include "auto_goldfish_dma_context.h"
 #include "IndexRangeCache.h"
 #include "SmartPtr.h"
 
 struct BufferData {
     BufferData();
-    BufferData(GLsizeiptr size, void * data);
+    BufferData(GLsizeiptr size, const void* data);
 
     // General buffer state
     GLsizeiptr m_size;
@@ -57,10 +55,14 @@
     GLbitfield m_mappedAccess;
     GLintptr m_mappedOffset;
     GLsizeiptr m_mappedLength;
+    uint64_t m_guest_paddr;
 
     // Internal bookkeeping
     FixedBuffer m_fixedBuffer; // actual buffer is shadowed here
     IndexRangeCache m_indexRangeCache;
+
+    // DMA support
+    AutoGoldfishDmaContext dma_buffer;
 };
 
 class ProgramData {
@@ -80,7 +82,7 @@
     bool m_initialized;
     bool m_locShiftWAR;
 
-    android::Vector<GLuint> m_shaders;
+    std::vector<GLuint> m_shaders;
 
 public:
     enum {
@@ -111,7 +113,7 @@
 };
 
 struct ShaderData {
-    typedef android::List<android::String8> StringList;
+    typedef std::vector<std::string> StringList;
     StringList samplerExternalNames;
     int refcount;
     std::vector<std::string> sources;
@@ -119,31 +121,23 @@
 
 class ShaderProgramData {
 public:
-    ShaderProgramData() {
-        shaderData = new ShaderData();
-        programData = new ProgramData();
-    }
-    ~ShaderProgramData() {
-        delete shaderData;
-        delete programData;
-    }
-    ShaderData* shaderData;
-    ProgramData* programData;
+    ShaderData shaderData;
+    ProgramData programData;
 };
 
 class GLSharedGroup {
 private:
     SharedTextureDataMap m_textureRecs;
-    android::DefaultKeyedVector<GLuint, BufferData*> m_buffers;
-    android::DefaultKeyedVector<GLuint, ProgramData*> m_programs;
-    android::DefaultKeyedVector<GLuint, ShaderData*> m_shaders;
-    android::DefaultKeyedVector<uint32_t, ShaderProgramData*> m_shaderPrograms;
+    std::map<GLuint, BufferData*> m_buffers;
+    std::map<GLuint, ProgramData*> m_programs;
+    std::map<GLuint, ShaderData*> m_shaders;
+    std::map<uint32_t, ShaderProgramData*> m_shaderPrograms;
     std::map<GLuint, uint32_t> m_shaderProgramIdMap;
 
     mutable android::Mutex m_lock;
 
-    void refShaderDataLocked(ssize_t shaderIdx);
-    void unrefShaderDataLocked(ssize_t shaderIdx);
+    void refShaderDataLocked(GLuint shader);
+    void unrefShaderDataLocked(GLuint shader);
 
     uint32_t m_shaderProgramId;
 
@@ -153,13 +147,13 @@
     bool isShaderOrProgramObject(GLuint obj);
     BufferData * getBufferData(GLuint bufferId);
     SharedTextureDataMap* getTextureData();
-    void    addBufferData(GLuint bufferId, GLsizeiptr size, void * data);
-    void    updateBufferData(GLuint bufferId, GLsizeiptr size, void * data);
+    void    addBufferData(GLuint bufferId, GLsizeiptr size, const void* data);
+    void    updateBufferData(GLuint bufferId, GLsizeiptr size, const void* data);
     void    setBufferUsage(GLuint bufferId, GLenum usage);
     void    setBufferMapped(GLuint bufferId, bool mapped);
     GLenum    getBufferUsage(GLuint bufferId);
     bool    isBufferMapped(GLuint bufferId);
-    GLenum  subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, void * data);
+    GLenum  subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, const void* data);
     void    deleteBufferData(GLuint);
 
     bool    isProgram(GLuint program);
diff --git a/shared/OpenglCodecCommon/IndexRangeCache.cpp b/shared/OpenglCodecCommon/IndexRangeCache.cpp
index c94e70c..4a73d22 100644
--- a/shared/OpenglCodecCommon/IndexRangeCache.cpp
+++ b/shared/OpenglCodecCommon/IndexRangeCache.cpp
@@ -57,12 +57,7 @@
     size_t invalidateStart = offset;
     size_t invalidateEnd = offset + size;
 
-    IndexRangeMap::iterator it =
-        mIndexRangeCache.lower_bound(
-                IndexRangeKey(GL_UNSIGNED_BYTE,
-                              offset,
-                              size,
-                              false));
+    IndexRangeMap::iterator it = mIndexRangeCache.begin();
 
     while (it != mIndexRangeCache.end()) {
         size_t rangeStart = it->first.offset;
diff --git a/shared/OpenglCodecCommon/IndexRangeCache.h b/shared/OpenglCodecCommon/IndexRangeCache.h
index 5f77958..4db2c56 100644
--- a/shared/OpenglCodecCommon/IndexRangeCache.h
+++ b/shared/OpenglCodecCommon/IndexRangeCache.h
@@ -75,15 +75,12 @@
             primitiveRestartEnabled(_primitiveRestart) { }
 
         bool operator<(const IndexRangeKey& rhs) const {
-            size_t start_other = rhs.offset;
             size_t end = offset + count * glSizeof(type);
+            size_t end_other = rhs.offset + rhs.count * glSizeof(rhs.type);
 
-            if (end <= start_other) {
-                return true;
-            }
-
+            if (offset != rhs.offset) return offset < rhs.offset;
+            if (end != end_other) return end < end_other;
             if (type != rhs.type) return type < rhs.type;
-            if (count != rhs.count) return count < rhs.count;
             if (primitiveRestartEnabled != rhs.primitiveRestartEnabled)
                 return primitiveRestartEnabled;
             return false;
diff --git a/shared/OpenglCodecCommon/KeyedVectorUtils.h b/shared/OpenglCodecCommon/KeyedVectorUtils.h
new file mode 100644
index 0000000..97dc9f1
--- /dev/null
+++ b/shared/OpenglCodecCommon/KeyedVectorUtils.h
@@ -0,0 +1,38 @@
+/*
+* Copyright (C) 2018 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.
+*/
+#pragma once
+
+#include <map>
+
+template <typename T>
+void clearObjectMap(std::map<GLuint, T>& v) {
+    typename std::map<GLuint, T>::iterator it = v.begin();
+    for (; it != v.end(); ++it) {
+        delete it->second;
+    }
+    v.clear();
+}
+
+template <typename K, typename V>
+V findObjectOrDefault(const std::map<K, V>& m, K key, V defaultValue = 0) {
+    typename std::map<K, V>::const_iterator it = m.find(key);
+
+    if (it == m.end()) {
+        return defaultValue;
+    }
+
+    return it->second;
+}
diff --git a/shared/OpenglCodecCommon/PortableMutex.h b/shared/OpenglCodecCommon/PortableMutex.h
new file mode 100644
index 0000000..b02ed61
--- /dev/null
+++ b/shared/OpenglCodecCommon/PortableMutex.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2007 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.
+ */
+
+#pragma once
+
+// TODO: switch to <mutex> and std::mutex when this code no longer needs
+// to compile for pre-C++11...
+
+#include  <sys/types.h>
+
+#if !defined(_WIN32)
+#include <pthread.h>
+#else
+#include <windows.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(_WIN32)
+
+typedef pthread_mutex_t mutex_t;
+
+static __inline__ void mutex_lock(mutex_t* lock) {
+  pthread_mutex_lock(lock);
+}
+
+static __inline__ void mutex_unlock(mutex_t* lock) {
+  pthread_mutex_unlock(lock);
+}
+
+static __inline__ int mutex_init(mutex_t* lock) {
+  return pthread_mutex_init(lock, NULL);
+}
+
+static __inline__ void mutex_destroy(mutex_t* lock) {
+  pthread_mutex_destroy(lock);
+}
+
+#else // !defined(_WIN32)
+
+typedef struct {
+  int init;
+  CRITICAL_SECTION lock[1];
+} mutex_t;
+
+#define MUTEX_INITIALIZER  { 0, {{ NULL, 0, 0, NULL, NULL, 0 }} }
+
+static __inline__ void mutex_lock(mutex_t* lock) {
+  if (!lock->init) {
+    lock->init = 1;
+    InitializeCriticalSection( lock->lock );
+    lock->init = 2;
+  } else while (lock->init != 2) {
+    Sleep(10);
+  }
+  EnterCriticalSection(lock->lock);
+}
+
+static __inline__ void mutex_unlock(mutex_t* lock) {
+  LeaveCriticalSection(lock->lock);
+}
+
+static __inline__ int mutex_init(mutex_t* lock) {
+  InitializeCriticalSection(lock->lock);
+  lock->init = 2;
+  return 0;
+}
+
+static __inline__ void mutex_destroy(mutex_t* lock) {
+  if (lock->init) {
+    lock->init = 0;
+    DeleteCriticalSection(lock->lock);
+  }
+}
+
+#endif // !defined(_WIN32)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/shared/OpenglCodecCommon/SmartPtr.h b/shared/OpenglCodecCommon/SmartPtr.h
index 4bdfbe4..3d821c8 100644
--- a/shared/OpenglCodecCommon/SmartPtr.h
+++ b/shared/OpenglCodecCommon/SmartPtr.h
@@ -16,7 +16,8 @@
 #ifndef __SMART_PTR_H
 #define __SMART_PTR_H
 
-#include <cutils/threads.h>
+#include <PortableMutex.h>
+
 #include <cutils/atomic.h>
 
 template <class T, bool threadSafe = false>
diff --git a/shared/OpenglCodecCommon/auto_goldfish_dma_context.cpp b/shared/OpenglCodecCommon/auto_goldfish_dma_context.cpp
new file mode 100644
index 0000000..280262d
--- /dev/null
+++ b/shared/OpenglCodecCommon/auto_goldfish_dma_context.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2018 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include "auto_goldfish_dma_context.h"
+
+namespace {
+goldfish_dma_context empty() {
+    goldfish_dma_context ctx;
+
+    ctx.mapped_addr = 0;
+    ctx.size = 0;
+    ctx.fd = -1;
+
+    return ctx;
+}
+
+void destroy(goldfish_dma_context *ctx) {
+    if (ctx->mapped_addr) {
+        goldfish_dma_unmap(ctx);
+    }
+    if (ctx->fd > 0) {
+        goldfish_dma_free(ctx);
+    }
+}
+}  // namespace
+
+AutoGoldfishDmaContext::AutoGoldfishDmaContext() : m_ctx(empty()) {}
+
+AutoGoldfishDmaContext::AutoGoldfishDmaContext(goldfish_dma_context *ctx)
+    : m_ctx(*ctx) {
+    *ctx = empty();
+}
+
+AutoGoldfishDmaContext::~AutoGoldfishDmaContext() {
+    destroy(&m_ctx);
+}
+
+void AutoGoldfishDmaContext::reset(goldfish_dma_context *ctx) {
+    destroy(&m_ctx);
+    if (ctx) {
+        m_ctx = *ctx;
+        *ctx = empty();
+    } else {
+        m_ctx = empty();
+    }
+}
+
+goldfish_dma_context AutoGoldfishDmaContext::release() {
+    goldfish_dma_context copy = m_ctx;
+    m_ctx = empty();
+    return copy;
+}
+
diff --git a/shared/OpenglCodecCommon/auto_goldfish_dma_context.h b/shared/OpenglCodecCommon/auto_goldfish_dma_context.h
new file mode 100644
index 0000000..7d97fc2
--- /dev/null
+++ b/shared/OpenglCodecCommon/auto_goldfish_dma_context.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2018 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef ANDROID_INCLUDE_HARDWARE_AUTO_GOLDFISH_DMA_CONTEXT_H
+#define ANDROID_INCLUDE_HARDWARE_AUTO_GOLDFISH_DMA_CONTEXT_H
+
+#include <inttypes.h>
+#include "goldfish_dma.h"
+
+// A C++ wrapper for goldfish_dma_context that releases resources in dctor.
+class AutoGoldfishDmaContext {
+public:
+    AutoGoldfishDmaContext();
+    explicit AutoGoldfishDmaContext(goldfish_dma_context *ctx);
+    ~AutoGoldfishDmaContext();
+
+    const goldfish_dma_context &get() const { return m_ctx; }
+    void reset(goldfish_dma_context *ctx);
+    goldfish_dma_context release();
+
+private:
+    AutoGoldfishDmaContext(const AutoGoldfishDmaContext &rhs);
+    AutoGoldfishDmaContext& operator=(const AutoGoldfishDmaContext &rhs);
+
+    goldfish_dma_context m_ctx;
+};
+
+#endif  // ANDROID_INCLUDE_HARDWARE_AUTO_GOLDFISH_DMA_CONTEXT_H
diff --git a/shared/OpenglCodecCommon/glUtils.h b/shared/OpenglCodecCommon/glUtils.h
index 2210699..e1f4ff3 100644
--- a/shared/OpenglCodecCommon/glUtils.h
+++ b/shared/OpenglCodecCommon/glUtils.h
@@ -16,6 +16,8 @@
 #ifndef __GL_UTILS_H__
 #define __GL_UTILS_H__
 
+#include <cutils/log.h>
+
 #include <stdio.h>
 #include <stdlib.h>
 
diff --git a/system/OpenglSystemCommon/goldfish_dma.cpp b/shared/OpenglCodecCommon/goldfish_dma.cpp
similarity index 76%
rename from system/OpenglSystemCommon/goldfish_dma.cpp
rename to shared/OpenglCodecCommon/goldfish_dma.cpp
index 046367d..36fa2ae 100644
--- a/system/OpenglSystemCommon/goldfish_dma.cpp
+++ b/shared/OpenglCodecCommon/goldfish_dma.cpp
@@ -16,10 +16,34 @@
 #include "qemu_pipe.h"
 
 #include <cutils/log.h>
+#include <errno.h>
+#include <linux/ioctl.h>
+#include <linux/types.h>
+#include <sys/cdefs.h>
 #include <sys/mman.h>
+#include <fcntl.h>
+#include <stdlib.h>
 #include <stdlib.h>
 #include <string.h>
 
+/* There is an ioctl associated with goldfish dma driver.
+ * Make it conflict with ioctls that are not likely to be used
+ * in the emulator.
+ * 'G'	00-3F	drivers/misc/sgi-gru/grulib.h	conflict!
+ * 'G'	00-0F	linux/gigaset_dev.h	conflict!
+ */
+#define GOLDFISH_DMA_IOC_MAGIC	'G'
+
+#define GOLDFISH_DMA_IOC_LOCK			_IOWR(GOLDFISH_DMA_IOC_MAGIC, 0, struct goldfish_dma_ioctl_info)
+#define GOLDFISH_DMA_IOC_UNLOCK			_IOWR(GOLDFISH_DMA_IOC_MAGIC, 1, struct goldfish_dma_ioctl_info)
+#define GOLDFISH_DMA_IOC_GETOFF			_IOWR(GOLDFISH_DMA_IOC_MAGIC, 2, struct goldfish_dma_ioctl_info)
+#define GOLDFISH_DMA_IOC_CREATE_REGION	_IOWR(GOLDFISH_DMA_IOC_MAGIC, 3, struct goldfish_dma_ioctl_info)
+
+struct goldfish_dma_ioctl_info {
+    uint64_t phys_begin;
+    uint64_t size;
+};
+
 int goldfish_dma_lock(struct goldfish_dma_context* cxt) {
     struct goldfish_dma_ioctl_info info;
 
@@ -97,7 +121,7 @@
     close(cxt->fd);
 }
 
-uint64_t goldfish_dma_guest_paddr(struct goldfish_dma_context* cxt) {
+uint64_t goldfish_dma_guest_paddr(const struct goldfish_dma_context* cxt) {
     struct goldfish_dma_ioctl_info info;
     ioctl(cxt->fd, GOLDFISH_DMA_IOC_GETOFF, &info);
     return info.phys_begin;
diff --git a/shared/OpenglCodecCommon/goldfish_dma.h b/shared/OpenglCodecCommon/goldfish_dma.h
new file mode 100644
index 0000000..db1e8d6
--- /dev/null
+++ b/shared/OpenglCodecCommon/goldfish_dma.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2016 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef ANDROID_INCLUDE_HARDWARE_GOLDFISH_DMA_H
+#define ANDROID_INCLUDE_HARDWARE_GOLDFISH_DMA_H
+
+#include <inttypes.h>
+
+// userspace interface
+struct goldfish_dma_context {
+	uint64_t mapped_addr;
+	uint32_t size;
+	int32_t fd;
+};
+
+int goldfish_dma_lock(struct goldfish_dma_context* cxt);
+int goldfish_dma_unlock(struct goldfish_dma_context* cxt);
+int goldfish_dma_create_region(uint32_t sz, struct goldfish_dma_context* res);
+
+void* goldfish_dma_map(struct goldfish_dma_context* cxt);
+int goldfish_dma_unmap(struct goldfish_dma_context* cxt);
+
+void goldfish_dma_write(struct goldfish_dma_context* cxt,
+                        const void* to_write,
+                        uint32_t sz);
+
+void goldfish_dma_free(goldfish_dma_context* cxt);
+uint64_t goldfish_dma_guest_paddr(const struct goldfish_dma_context* cxt);
+
+#endif
diff --git a/shared/OpenglCodecCommon/goldfish_dma_host.cpp b/shared/OpenglCodecCommon/goldfish_dma_host.cpp
new file mode 100644
index 0000000..93dcfa3
--- /dev/null
+++ b/shared/OpenglCodecCommon/goldfish_dma_host.cpp
@@ -0,0 +1,47 @@
+// Copyright (C) 2018 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 "goldfish_dma.h"
+
+int goldfish_dma_lock(struct goldfish_dma_context* cxt) {
+    return 0;
+}
+
+int goldfish_dma_unlock(struct goldfish_dma_context* cxt) {
+    return 0;
+}
+
+int goldfish_dma_create_region(uint32_t sz, struct goldfish_dma_context* res) {
+    return 0;
+}
+
+void* goldfish_dma_map(struct goldfish_dma_context* cxt) {
+    return 0;
+}
+
+int goldfish_dma_unmap(struct goldfish_dma_context* cxt) {
+    return 0;
+}
+
+void goldfish_dma_write(struct goldfish_dma_context* cxt,
+                               const void* to_write,
+                               uint32_t sz) {
+}
+
+void goldfish_dma_free(goldfish_dma_context* cxt) {
+}
+
+uint64_t goldfish_dma_guest_paddr(const struct goldfish_dma_context* cxt) {
+    return 0;
+}
+
diff --git a/system/OpenglSystemCommon/gralloc_cb.h b/shared/OpenglCodecCommon/gralloc_cb.h
similarity index 91%
rename from system/OpenglSystemCommon/gralloc_cb.h
rename to shared/OpenglCodecCommon/gralloc_cb.h
index 04a7040..f874c12 100644
--- a/system/OpenglSystemCommon/gralloc_cb.h
+++ b/shared/OpenglCodecCommon/gralloc_cb.h
@@ -22,6 +22,7 @@
 #include <cutils/native_handle.h>
 
 #include "goldfish_dma.h"
+#include "qemu_pipe.h"
 
 #define BUFFER_HANDLE_MAGIC ((int)0xabfabfab)
 #define CB_HANDLE_NUM_INTS(nfds) (int)((sizeof(cb_handle_t) - (nfds)*sizeof(int)) / sizeof(int))
@@ -64,7 +65,7 @@
         emuFrameworkFormat(p_emuFrameworkFormat)
     {
         goldfish_dma.fd = -1;
-        dmafd = -1;
+        refcount_pipe_fd = QEMU_PIPE_INVALID_HANDLE;
         version = sizeof(native_handle);
         numFds = 0;
         numInts = CB_HANDLE_NUM_INTS(numFds);
@@ -82,11 +83,15 @@
         numInts = CB_HANDLE_NUM_INTS(numFds);
     }
 
-    void setDmaFd(int fd) {
-        if (fd >= 0) {
+    bool hasRefcountPipe() {
+        return qemu_pipe_valid(refcount_pipe_fd);
+    }
+
+    void setRefcountPipeFd(QEMU_PIPE_HANDLE fd) {
+        if (qemu_pipe_valid(fd)) {
             numFds++;
         }
-        dmafd = fd;
+        refcount_pipe_fd = fd;
         numInts = CB_HANDLE_NUM_INTS(numFds);
     }
 
@@ -103,7 +108,7 @@
 
     // file-descriptors
     int fd;  // ashmem fd (-1 of ashmem region did not allocated, i.e. no SW access needed)
-    int dmafd; // goldfish dma fd.
+    QEMU_PIPE_HANDLE refcount_pipe_fd; // goldfish pipe service for gralloc refcounting fd.
 
     // ints
     int magic;              // magic number in order to validate a pointer to be a cb_handle_t
diff --git a/system/OpenglSystemCommon/qemu_pipe.h b/shared/OpenglCodecCommon/qemu_pipe.h
similarity index 66%
rename from system/OpenglSystemCommon/qemu_pipe.h
rename to shared/OpenglCodecCommon/qemu_pipe.h
index 52f4ee7..62de57f 100644
--- a/system/OpenglSystemCommon/qemu_pipe.h
+++ b/shared/OpenglCodecCommon/qemu_pipe.h
@@ -16,6 +16,32 @@
 #ifndef ANDROID_INCLUDE_HARDWARE_QEMU_PIPE_H
 #define ANDROID_INCLUDE_HARDWARE_QEMU_PIPE_H
 
+#ifdef HOST_BUILD
+
+#include <sys/types.h>
+
+typedef void* QEMU_PIPE_HANDLE;
+
+#define QEMU_PIPE_INVALID_HANDLE NULL
+
+QEMU_PIPE_HANDLE qemu_pipe_open(const char* pipeName);
+void qemu_pipe_close(QEMU_PIPE_HANDLE pipe);
+
+ssize_t qemu_pipe_read(QEMU_PIPE_HANDLE pipe, void* buffer, size_t len);
+ssize_t qemu_pipe_write(QEMU_PIPE_HANDLE pipe, const void* buffer, size_t len);
+
+bool qemu_pipe_try_again();
+bool qemu_pipe_valid(QEMU_PIPE_HANDLE pipe);
+
+void qemu_pipe_print_error(QEMU_PIPE_HANDLE pipe);
+
+#else
+
+typedef int QEMU_PIPE_HANDLE;
+
+#define QEMU_PIPE_INVALID_HANDLE (-1)
+
+#include <cutils/log.h>
 #include <sys/cdefs.h>
 #include <unistd.h>
 #include <fcntl.h>
@@ -30,7 +56,7 @@
 #  define  D(...)   do{}while(0)
 #endif
 
-static bool WriteFully(int fd, const void* data, size_t byte_count) {
+static bool WriteFully(QEMU_PIPE_HANDLE fd, const void* data, size_t byte_count) {
   const uint8_t* p = (const uint8_t*)(data);
   size_t remaining = byte_count;
   while (remaining > 0) {
@@ -64,12 +90,11 @@
  * except for a few special cases (e.g. GSM modem), where EBUSY will be
  * returned if more than one client tries to connect to it.
  */
-static __inline__ int
-qemu_pipe_open(const char*  pipeName)
-{
+static __inline__ QEMU_PIPE_HANDLE
+qemu_pipe_open(const char* pipeName) {
     char  buff[256];
     int   buffLen;
-    int   fd;
+    QEMU_PIPE_HANDLE   fd;
 
     if (pipeName == NULL || pipeName[0] == '\0') {
         errno = EINVAL;
@@ -97,4 +122,36 @@
     return fd;
 }
 
+static __inline__ void
+qemu_pipe_close(QEMU_PIPE_HANDLE pipe) {
+    close(pipe);
+}
+
+static __inline__ ssize_t
+qemu_pipe_read(QEMU_PIPE_HANDLE pipe, void* buffer, size_t len) {
+    return read(pipe, buffer, len);
+}
+
+static __inline__ ssize_t
+qemu_pipe_write(QEMU_PIPE_HANDLE pipe, const void* buffer, size_t len) {
+    return write(pipe, buffer, len);
+}
+
+static __inline__ bool
+qemu_pipe_try_again() {
+    return errno == EINTR;
+}
+
+static __inline__ bool
+qemu_pipe_valid(QEMU_PIPE_HANDLE pipe) {
+    return pipe >= 0;
+}
+
+static __inline__ void
+qemu_pipe_print_error(QEMU_PIPE_HANDLE pipe) {
+    ALOGE("pipe error: fd %d errno %d", pipe, errno);
+}
+
+#endif // !HOST_BUILD
+
 #endif /* ANDROID_INCLUDE_HARDWARE_QEMU_PIPE_H */
diff --git a/shared/OpenglCodecCommon/qemu_pipe_host.cpp b/shared/OpenglCodecCommon/qemu_pipe_host.cpp
new file mode 100644
index 0000000..b4dc2af
--- /dev/null
+++ b/shared/OpenglCodecCommon/qemu_pipe_host.cpp
@@ -0,0 +1,50 @@
+// Copyright 2018 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 "qemu_pipe.h"
+
+#include "android/emulation/hostpipe/HostGoldfishPipe.h"
+
+#include <cutils/log.h>
+
+using android::HostGoldfishPipeDevice;
+
+QEMU_PIPE_HANDLE qemu_pipe_open(const char* pipeName) {
+    return HostGoldfishPipeDevice::get()->connect(pipeName);
+}
+
+void qemu_pipe_close(QEMU_PIPE_HANDLE pipe) {
+    HostGoldfishPipeDevice::get()->close(pipe);
+}
+
+ssize_t qemu_pipe_read(QEMU_PIPE_HANDLE pipe, void* buffer, size_t len) {
+    return HostGoldfishPipeDevice::get()->read(pipe, buffer, len);
+}
+
+ssize_t qemu_pipe_write(QEMU_PIPE_HANDLE pipe, const void* buffer, size_t len) {
+    return HostGoldfishPipeDevice::get()->write(pipe, buffer, len);
+}
+
+bool qemu_pipe_try_again() {
+    int err = HostGoldfishPipeDevice::get()->getErrno();
+    return err == EINTR || err == EAGAIN;
+}
+
+bool qemu_pipe_valid(QEMU_PIPE_HANDLE pipe) {
+    return pipe != NULL;
+}
+
+void qemu_pipe_print_error(QEMU_PIPE_HANDLE pipe) {
+    int err = HostGoldfishPipeDevice::get()->getErrno();
+    ALOGE("pipe error: pipe %p err %d", pipe, err);
+}
diff --git a/system/GLESv1/CMakeLists.txt b/system/GLESv1/CMakeLists.txt
new file mode 100644
index 0000000..9642bb2
--- /dev/null
+++ b/system/GLESv1/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/GLESv1/Android.mk" "e095cb082e3791719749cfc80b90560afd7348eb0d7895449d2509aa129bea75")
+set(GLESv1_CM_emulation_src gl.cpp)
+android_add_shared_library(GLESv1_CM_emulation)
+target_include_directories(GLESv1_CM_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(GLESv1_CM_emulation PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"GLES_emulation\"")
+target_compile_options(GLESv1_CM_emulation PRIVATE "-fvisibility=default")
+target_link_libraries(GLESv1_CM_emulation PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/GLESv1/gl.cpp b/system/GLESv1/gl.cpp
index 6e07004..56e1630 100644
--- a/system/GLESv1/gl.cpp
+++ b/system/GLESv1/gl.cpp
@@ -20,7 +20,6 @@
 #include "GLES/gl.h"
 #include "GLES/glext.h"
 #include "ErrorLog.h"
-#include "gralloc_cb.h"
 #include "ThreadInfo.h"
 #include "EGLImage.h"
 
@@ -46,6 +45,11 @@
     if (!rcEnc) { \
         ALOGE("egl: Failed to get renderControl encoder context\n"); \
         return ret; \
+    } \
+    Gralloc *grallocHelper = hostCon->grallocHelper(); \
+    if (!grallocHelper) { \
+        ALOGE("egl: Failed to get grallocHelper\n"); \
+        return ret; \
     }
 
 //GL extensions
@@ -74,7 +78,7 @@
 
         ctx->override2DTextureTarget(target);
         rcEnc->rcBindTexture(rcEnc,
-                ((cb_handle_t *)(native_buffer->handle))->hostHandle);
+                grallocHelper->getHostHandle(native_buffer->handle));
         ctx->restore2DTextureTarget();
     }
     else if (image->target == EGL_GL_TEXTURE_2D_KHR) {
@@ -107,7 +111,8 @@
         }
 
         DEFINE_AND_VALIDATE_HOST_CONNECTION();
-        rcEnc->rcBindRenderbuffer(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle);
+        rcEnc->rcBindRenderbuffer(rcEnc,
+                grallocHelper->getHostHandle(native_buffer->handle));
     } else {
         //TODO
     }
diff --git a/system/GLESv1_enc/Android.mk b/system/GLESv1_enc/Android.mk
index fd12395..48ee51f 100644
--- a/system/GLESv1_enc/Android.mk
+++ b/system/GLESv1_enc/Android.mk
@@ -12,7 +12,7 @@
         gl_enc.cpp \
         gl_entry.cpp
 
-$(call emugl-import,libOpenglCodecCommon)
+$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX))
 $(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
 $(call emugl-export,C_INCLUDES,$(intermediates))
 
diff --git a/system/GLESv1_enc/CMakeLists.txt b/system/GLESv1_enc/CMakeLists.txt
new file mode 100644
index 0000000..1b86cdb
--- /dev/null
+++ b/system/GLESv1_enc/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc/Android.mk" "953e6b7371d10eed63a4be555f8f1fb6f347338484a78102fa8f55dff96f5d3b")
+set(GLESv1_enc_src GLEncoder.cpp GLEncoderUtils.cpp gl_client_context.cpp gl_enc.cpp gl_entry.cpp)
+android_add_shared_library(GLESv1_enc)
+target_include_directories(GLESv1_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(GLESv1_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"emuglGLESv1_enc\"")
+target_compile_options(GLESv1_enc PRIVATE "-fvisibility=default")
+target_link_libraries(GLESv1_enc PRIVATE OpenglCodecCommon_host cutils utils log android-emu-shared)
\ No newline at end of file
diff --git a/system/GLESv1_enc/gl_enc.cpp b/system/GLESv1_enc/gl_enc.cpp
index 79df3d7..31c1269 100644
--- a/system/GLESv1_enc/gl_enc.cpp
+++ b/system/GLESv1_enc/gl_enc.cpp
@@ -8,6 +8,8 @@
 #include "gl_enc.h"
 
 
+#include <vector>
+
 #include <stdio.h>
 
 namespace {
diff --git a/system/GLESv2/CMakeLists.txt b/system/GLESv2/CMakeLists.txt
new file mode 100644
index 0000000..7738bcd
--- /dev/null
+++ b/system/GLESv2/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/GLESv2/Android.mk" "d8f9dda69ec57ad8b7a65f02c3335b16a4724f612dec1d1a2cd793c28c0a10f9")
+set(GLESv2_emulation_src gl2.cpp)
+android_add_shared_library(GLESv2_emulation)
+target_include_directories(GLESv2_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(GLESv2_emulation PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"GLESv2_emulation\"")
+target_compile_options(GLESv2_emulation PRIVATE "-fvisibility=default")
+target_link_libraries(GLESv2_emulation PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/GLESv2/gl2.cpp b/system/GLESv2/gl2.cpp
index 0a2bf8e..a36bdd3 100644
--- a/system/GLESv2/gl2.cpp
+++ b/system/GLESv2/gl2.cpp
@@ -20,7 +20,6 @@
 #include "GLES/gl.h"
 #include "GLES/glext.h"
 #include "ErrorLog.h"
-#include "gralloc_cb.h"
 #include "ThreadInfo.h"
 #include "EGLImage.h"
 
@@ -46,6 +45,11 @@
     if (!rcEnc) { \
         ALOGE("egl: Failed to get renderControl encoder context\n"); \
         return ret; \
+    } \
+    Gralloc *grallocHelper = hostCon->grallocHelper(); \
+    if (!grallocHelper) { \
+        ALOGE("egl: Failed to get grallocHelper\n"); \
+        return ret; \
     }
 
 //GL extensions
@@ -76,7 +80,8 @@
 
         ctx->override2DTextureTarget(target);
         ctx->associateEGLImage(target, hostImage);
-        rcEnc->rcBindTexture(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle);
+        rcEnc->rcBindTexture(rcEnc,
+                grallocHelper->getHostHandle(native_buffer->handle));
         ctx->restore2DTextureTarget(target);
     }
     else if (image->target == EGL_GL_TEXTURE_2D_KHR) {
@@ -109,7 +114,8 @@
         }
 
         DEFINE_AND_VALIDATE_HOST_CONNECTION();
-        rcEnc->rcBindRenderbuffer(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle);
+        rcEnc->rcBindRenderbuffer(rcEnc,
+                grallocHelper->getHostHandle(native_buffer->handle));
     } else {
         //TODO
     }
diff --git a/system/GLESv2_enc/Android.mk b/system/GLESv2_enc/Android.mk
index f61c9f7..12bb013 100644
--- a/system/GLESv2_enc/Android.mk
+++ b/system/GLESv2_enc/Android.mk
@@ -15,7 +15,7 @@
 LOCAL_CFLAGS += -DLOG_TAG=\"emuglGLESv2_enc\"
 
 $(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
-$(call emugl-import,libOpenglCodecCommon)
+$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX))
 
 $(call emugl-end-module)
 
diff --git a/system/GLESv2_enc/CMakeLists.txt b/system/GLESv2_enc/CMakeLists.txt
new file mode 100644
index 0000000..87534fc
--- /dev/null
+++ b/system/GLESv2_enc/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc/Android.mk" "61772afe3e393d4ff6add7929ed232da8e614e44bf903018a91c774bc5b54a18")
+set(GLESv2_enc_src GL2EncoderUtils.cpp GL2Encoder.cpp GLESv2Validation.cpp gl2_client_context.cpp gl2_enc.cpp gl2_entry.cpp ../enc_common/IOStream_common.cpp)
+android_add_shared_library(GLESv2_enc)
+target_include_directories(GLESv2_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(GLESv2_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"emuglGLESv2_enc\"")
+target_compile_options(GLESv2_enc PRIVATE "-fvisibility=default")
+target_link_libraries(GLESv2_enc PRIVATE OpenglCodecCommon_host cutils utils log android-emu-shared)
\ No newline at end of file
diff --git a/system/GLESv2_enc/GL2Encoder.cpp b/system/GLESv2_enc/GL2Encoder.cpp
index 8b07e66..220f198 100755
--- a/system/GLESv2_enc/GL2Encoder.cpp
+++ b/system/GLESv2_enc/GL2Encoder.cpp
@@ -77,11 +77,24 @@
     m_state = NULL;
     m_error = GL_NO_ERROR;
     m_num_compressedTextureFormats = 0;
+    m_max_combinedTextureImageUnits = 0;
+    m_max_vertexTextureImageUnits = 0;
+    m_max_textureImageUnits = 0;
     m_max_cubeMapTextureSize = 0;
     m_max_renderBufferSize = 0;
     m_max_textureSize = 0;
     m_max_3d_textureSize = 0;
     m_max_vertexAttribStride = 0;
+
+    m_max_transformFeedbackSeparateAttribs = 0;
+    m_max_uniformBufferBindings = 0;
+    m_max_colorAttachments = 0;
+    m_max_drawBuffers = 0;
+
+    m_max_atomicCounterBufferBindings = 0;
+    m_max_shaderStorageBufferBindings = 0;
+    m_max_vertexAttribBindings = 0;
+
     m_compressedTextureFormats = NULL;
 
     m_ssbo_offset_align = 0;
@@ -536,7 +549,7 @@
     SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION);
     SET_ERROR_IF(size<0, GL_INVALID_VALUE);
 
-    ctx->m_shared->updateBufferData(bufferId, size, (void*)data);
+    ctx->m_shared->updateBufferData(bufferId, size, data);
     ctx->m_shared->setBufferUsage(bufferId, usage);
     ctx->m_glBufferData_enc(self, target, size, data, usage);
 }
@@ -549,7 +562,7 @@
     SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION);
     SET_ERROR_IF(ctx->isBufferTargetMapped(target), GL_INVALID_OPERATION);
 
-    GLenum res = ctx->m_shared->subUpdateBufferData(bufferId, offset, size, (void*)data);
+    GLenum res = ctx->m_shared->subUpdateBufferData(bufferId, offset, size, data);
     SET_ERROR_IF(res, res);
 
     ctx->m_glBufferSubData_enc(self, target, offset, size, data);
@@ -632,7 +645,6 @@
 void GL2Encoder::s_glGetIntegerv(void *self, GLenum param, GLint *ptr)
 {
     GL2Encoder *ctx = (GL2Encoder *) self;
-    assert(ctx->m_state != NULL);
     GLClientState* state = ctx->m_state;
 
     switch (param) {
@@ -663,23 +675,43 @@
     }
 
     case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
-    case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
-    case GL_MAX_TEXTURE_IMAGE_UNITS:
-        ctx->safe_glGetIntegerv(param, ptr);
-        *ptr = MIN(*ptr, GLClientState::MAX_TEXTURE_UNITS);
+        if (ctx->m_max_combinedTextureImageUnits != 0) {
+            *ptr = ctx->m_max_combinedTextureImageUnits;
+        } else {
+            ctx->safe_glGetIntegerv(param, ptr);
+            ctx->m_max_combinedTextureImageUnits = *ptr;
+        }
         break;
-
+    case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+        if (ctx->m_max_vertexTextureImageUnits != 0) {
+            *ptr = ctx->m_max_vertexTextureImageUnits;
+        } else {
+            ctx->safe_glGetIntegerv(param, ptr);
+            ctx->m_max_vertexTextureImageUnits = *ptr;
+        }
+        break;
+    case GL_MAX_TEXTURE_IMAGE_UNITS:
+        if (ctx->m_max_textureImageUnits != 0) {
+            *ptr = ctx->m_max_textureImageUnits;
+        } else {
+            ctx->safe_glGetIntegerv(param, ptr);
+            ctx->m_max_textureImageUnits = *ptr;
+        }
+        break;
     case GL_TEXTURE_BINDING_2D:
+        SET_ERROR_IF(!state, GL_INVALID_OPERATION);
         *ptr = state->getBoundTexture(GL_TEXTURE_2D);
         break;
     case GL_TEXTURE_BINDING_EXTERNAL_OES:
+        SET_ERROR_IF(!state, GL_INVALID_OPERATION);
         *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES);
         break;
 
     case GL_MAX_VERTEX_ATTRIBS:
-        if (!ctx->m_state->getClientStateParameter<GLint>(param, ptr)) {
+        SET_ERROR_IF(!state, GL_INVALID_OPERATION);
+        if (!state->getClientStateParameter<GLint>(param, ptr)) {
             ctx->safe_glGetIntegerv(param, ptr);
-            ctx->m_state->setMaxVertexAttribs(*ptr);
+            state->setMaxVertexAttribs(*ptr);
         }
         break;
     case GL_MAX_VERTEX_ATTRIB_STRIDE:
@@ -749,27 +781,80 @@
     // Checks for version-incompatible enums.
     // Not allowed in vanilla ES 2.0.
     case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
+        SET_ERROR_IF(ctx->majorVersion() < 3, GL_INVALID_ENUM);
+        if (ctx->m_max_transformFeedbackSeparateAttribs != 0) {
+            *ptr = ctx->m_max_transformFeedbackSeparateAttribs;
+        } else {
+            ctx->safe_glGetIntegerv(param, ptr);
+            ctx->m_max_transformFeedbackSeparateAttribs = *ptr;
+        }
+        break;
     case GL_MAX_UNIFORM_BUFFER_BINDINGS:
         SET_ERROR_IF(ctx->majorVersion() < 3, GL_INVALID_ENUM);
-        ctx->safe_glGetIntegerv(param, ptr);
+        if (ctx->m_max_uniformBufferBindings != 0) {
+            *ptr = ctx->m_max_uniformBufferBindings;
+        } else {
+            ctx->safe_glGetIntegerv(param, ptr);
+            ctx->m_max_uniformBufferBindings = *ptr;
+        }
         break;
     case GL_MAX_COLOR_ATTACHMENTS:
+        SET_ERROR_IF(ctx->majorVersion() < 3 &&
+                     !ctx->hasExtension("GL_EXT_draw_buffers"), GL_INVALID_ENUM);
+        if (ctx->m_max_colorAttachments != 0) {
+            *ptr = ctx->m_max_colorAttachments;
+        } else {
+            ctx->safe_glGetIntegerv(param, ptr);
+            ctx->m_max_colorAttachments = *ptr;
+        }
+        break;
     case GL_MAX_DRAW_BUFFERS:
         SET_ERROR_IF(ctx->majorVersion() < 3 &&
                      !ctx->hasExtension("GL_EXT_draw_buffers"), GL_INVALID_ENUM);
-        ctx->safe_glGetIntegerv(param, ptr);
+        if (ctx->m_max_drawBuffers != 0) {
+            *ptr = ctx->m_max_drawBuffers;
+        } else {
+            ctx->safe_glGetIntegerv(param, ptr);
+            ctx->m_max_drawBuffers = *ptr;
+        }
         break;
     // Not allowed in ES 3.0.
     case GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
+        SET_ERROR_IF(ctx->majorVersion() < 3 ||
+                     (ctx->majorVersion() == 3 &&
+                      ctx->minorVersion() == 0), GL_INVALID_ENUM);
+        if (ctx->m_max_atomicCounterBufferBindings != 0) {
+            *ptr = ctx->m_max_atomicCounterBufferBindings;
+        } else {
+            ctx->safe_glGetIntegerv(param, ptr);
+            ctx->m_max_atomicCounterBufferBindings = *ptr;
+        }
+        break;
     case GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
+        SET_ERROR_IF(ctx->majorVersion() < 3 ||
+                     (ctx->majorVersion() == 3 &&
+                      ctx->minorVersion() == 0), GL_INVALID_ENUM);
+        if (ctx->m_max_shaderStorageBufferBindings != 0) {
+            *ptr = ctx->m_max_shaderStorageBufferBindings;
+        } else {
+            ctx->safe_glGetIntegerv(param, ptr);
+            ctx->m_max_shaderStorageBufferBindings = *ptr;
+        }
+        break;
     case GL_MAX_VERTEX_ATTRIB_BINDINGS:
         SET_ERROR_IF(ctx->majorVersion() < 3 ||
                      (ctx->majorVersion() == 3 &&
                       ctx->minorVersion() == 0), GL_INVALID_ENUM);
-        ctx->safe_glGetIntegerv(param, ptr);
+        if (ctx->m_max_vertexAttribBindings != 0) {
+            *ptr = ctx->m_max_vertexAttribBindings;
+        } else {
+            ctx->safe_glGetIntegerv(param, ptr);
+            ctx->m_max_vertexAttribBindings = *ptr;
+        }
         break;
     default:
-        if (!ctx->m_state->getClientStateParameter<GLint>(param, ptr)) {
+        SET_ERROR_IF(!state, GL_INVALID_OPERATION);
+        if (!state->getClientStateParameter<GLint>(param, ptr)) {
             ctx->safe_glGetIntegerv(param, ptr);
         }
         break;
@@ -780,7 +865,6 @@
 void GL2Encoder::s_glGetFloatv(void *self, GLenum param, GLfloat *ptr)
 {
     GL2Encoder *ctx = (GL2Encoder *)self;
-    assert(ctx->m_state != NULL);
     GLClientState* state = ctx->m_state;
 
     switch (param) {
@@ -805,19 +889,36 @@
     case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
     case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
     case GL_MAX_TEXTURE_IMAGE_UNITS:
-        ctx->safe_glGetFloatv(param, ptr);
-        *ptr = MIN(*ptr, (GLfloat)GLClientState::MAX_TEXTURE_UNITS);
-        break;
-
+    case GL_MAX_VERTEX_ATTRIBS:
+    case GL_MAX_VERTEX_ATTRIB_STRIDE:
+    case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+    case GL_MAX_RENDERBUFFER_SIZE:
+    case GL_MAX_TEXTURE_SIZE:
+    case GL_MAX_3D_TEXTURE_SIZE:
+    case GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
+    case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
+    case GL_MAX_SAMPLES:
+    case GL_MAX_COLOR_TEXTURE_SAMPLES:
+    case GL_MAX_INTEGER_SAMPLES:
+    case GL_MAX_DEPTH_TEXTURE_SAMPLES:
+    case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
+    case GL_MAX_UNIFORM_BUFFER_BINDINGS:
+    case GL_MAX_COLOR_ATTACHMENTS:
+    case GL_MAX_DRAW_BUFFERS:
+    case GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
+    case GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
+    case GL_MAX_VERTEX_ATTRIB_BINDINGS:
     case GL_TEXTURE_BINDING_2D:
-        *ptr = (GLfloat)state->getBoundTexture(GL_TEXTURE_2D);
+    case GL_TEXTURE_BINDING_EXTERNAL_OES: {
+        GLint res;
+        s_glGetIntegerv(ctx, param, &res);
+        *ptr = (GLfloat)res;
         break;
-    case GL_TEXTURE_BINDING_EXTERNAL_OES:
-        *ptr = (GLfloat)state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES);
-        break;
+    }
 
     default:
-        if (!ctx->m_state->getClientStateParameter<GLfloat>(param, ptr)) {
+        SET_ERROR_IF(!state, GL_INVALID_OPERATION);
+        if (!state->getClientStateParameter<GLfloat>(param, ptr)) {
             ctx->safe_glGetFloatv(param, ptr);
         }
         break;
@@ -828,7 +929,6 @@
 void GL2Encoder::s_glGetBooleanv(void *self, GLenum param, GLboolean *ptr)
 {
     GL2Encoder *ctx = (GL2Encoder *)self;
-    assert(ctx->m_state != NULL);
     GLClientState* state = ctx->m_state;
 
     switch (param) {
@@ -850,16 +950,39 @@
         break;
     }
 
+    case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
+    case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+    case GL_MAX_TEXTURE_IMAGE_UNITS:
+    case GL_MAX_VERTEX_ATTRIBS:
+    case GL_MAX_VERTEX_ATTRIB_STRIDE:
+    case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+    case GL_MAX_RENDERBUFFER_SIZE:
+    case GL_MAX_TEXTURE_SIZE:
+    case GL_MAX_3D_TEXTURE_SIZE:
+    case GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
+    case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
+    case GL_MAX_SAMPLES:
+    case GL_MAX_COLOR_TEXTURE_SAMPLES:
+    case GL_MAX_INTEGER_SAMPLES:
+    case GL_MAX_DEPTH_TEXTURE_SAMPLES:
+    case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
+    case GL_MAX_UNIFORM_BUFFER_BINDINGS:
+    case GL_MAX_COLOR_ATTACHMENTS:
+    case GL_MAX_DRAW_BUFFERS:
+    case GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
+    case GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
+    case GL_MAX_VERTEX_ATTRIB_BINDINGS:
     case GL_TEXTURE_BINDING_2D:
-        *ptr = state->getBoundTexture(GL_TEXTURE_2D) != 0 ? GL_TRUE : GL_FALSE;
+    case GL_TEXTURE_BINDING_EXTERNAL_OES: {
+        GLint res;
+        s_glGetIntegerv(ctx, param, &res);
+        *ptr = res == 0 ? GL_FALSE : GL_TRUE;
         break;
-    case GL_TEXTURE_BINDING_EXTERNAL_OES:
-        *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES) != 0
-                ? GL_TRUE : GL_FALSE;
-        break;
+    }
 
     default:
-        if (!ctx->m_state->getClientStateParameter<GLboolean>(param, ptr)) {
+        SET_ERROR_IF(!state, GL_INVALID_OPERATION);
+        if (!state->getClientStateParameter<GLboolean>(param, ptr)) {
             ctx->safe_glGetBooleanv(param, ptr);
         }
         *ptr = (*ptr != 0) ? GL_TRUE : GL_FALSE;
@@ -1133,7 +1256,7 @@
                     if (buf) {
                         ALOGE("Out of bounds vertex attribute info: "
                                 "clientArray? %d attribute %d vbo %u allocedBufferSize %u bufferDataSpecified? %d wantedStart %u wantedEnd %u",
-                                hasClientArrays, i, bufferObject, buf->m_size, buf != NULL, firstIndex, firstIndex + bufLen);
+                                hasClientArrays, i, bufferObject, (unsigned int)buf->m_size, buf != NULL, firstIndex, firstIndex + bufLen);
                     }
                     m_glDisableVertexAttribArray_enc(this, i);
                 }
@@ -1255,6 +1378,8 @@
                             &maxIndex);
     }
 
+    if (count == 0) return;
+
     bool adjustIndices = true;
     if (ctx->m_state->currentIndexVbo() != 0) {
         if (!has_client_vertex_arrays) {
@@ -1414,8 +1539,10 @@
         do {
             c++;
         } while (isalnum(*c) || *c == '_');
+
+        size_t len = (size_t)(c - name_start);
         data->samplerExternalNames.push_back(
-                android::String8(name_start, c - name_start));
+            std::string(name_start, len));
 
         // We only need to perform a string replacement for the original
         // occurrence of samplerExternalOES if a #define was used.
@@ -2691,6 +2818,20 @@
     return ctx->glUnmapBuffer(ctx, target);
 }
 
+void* GL2Encoder::s_glMapBufferRangeAEMUImpl(GL2Encoder* ctx, GLenum target,
+                                             GLintptr offset, GLsizeiptr length,
+                                             GLbitfield access, BufferData* buf) {
+    char* bits = (char*)buf->m_fixedBuffer.ptr() + offset;
+
+    ctx->glMapBufferRangeAEMU(
+            ctx, target,
+            offset, length,
+            access,
+            bits);
+
+    return bits;
+}
+
 void* GL2Encoder::s_glMapBufferRange(void* self, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
     GL2Encoder* ctx = (GL2Encoder*)self;
     GLClientState* state = ctx->m_state;
@@ -2729,14 +2870,37 @@
     buf->m_mappedOffset = offset;
     buf->m_mappedLength = length;
 
-    char* todo = (char*)buf->m_fixedBuffer.ptr() + offset;
-    ctx->glMapBufferRangeAEMU(
-            ctx, target,
-            offset, length,
-            access,
-            todo);
+    if (ctx->hasExtension("ANDROID_EMU_dma_v2")) {
+        if (buf->dma_buffer.get().size < length) {
+            goldfish_dma_context region;
 
-    return todo;
+            const int PAGE_BITS = 12;
+            GLsizeiptr aligned_length = (length + (1 << PAGE_BITS) - 1) & ~((1 << PAGE_BITS) - 1);
+
+            if (goldfish_dma_create_region(aligned_length, &region)) {
+                buf->dma_buffer.reset(NULL);
+                return s_glMapBufferRangeAEMUImpl(ctx, target, offset, length, access, buf);
+            }
+
+            if (!goldfish_dma_map(&region)) {
+                buf->dma_buffer.reset(NULL);
+                return s_glMapBufferRangeAEMUImpl(ctx, target, offset, length, access, buf);
+            }
+
+            buf->m_guest_paddr = goldfish_dma_guest_paddr(&region);
+            buf->dma_buffer.reset(&region);
+        }
+
+        ctx->glMapBufferRangeDMA(
+                ctx, target,
+                offset, length,
+                access,
+                buf->m_guest_paddr);
+
+        return reinterpret_cast<void*>(buf->dma_buffer.get().mapped_addr);
+    } else {
+        return s_glMapBufferRangeAEMUImpl(ctx, target, offset, length, access, buf);
+    }
 }
 
 GLboolean GL2Encoder::s_glUnmapBuffer(void* self, GLenum target) {
@@ -2764,13 +2928,27 @@
 
     GLboolean host_res = GL_TRUE;
 
-    ctx->glUnmapBufferAEMU(
-            ctx, target,
-            buf->m_mappedOffset,
-            buf->m_mappedLength,
-            buf->m_mappedAccess,
-            (void*)((char*)buf->m_fixedBuffer.ptr() + buf->m_mappedOffset),
-            &host_res);
+    if (buf->dma_buffer.get().mapped_addr) {
+        memcpy(static_cast<char*>(buf->m_fixedBuffer.ptr()) + buf->m_mappedOffset,
+               reinterpret_cast<void*>(buf->dma_buffer.get().mapped_addr),
+               buf->m_mappedLength);
+
+        ctx->glUnmapBufferDMA(
+                ctx, target,
+                buf->m_mappedOffset,
+                buf->m_mappedLength,
+                buf->m_mappedAccess,
+                goldfish_dma_guest_paddr(&buf->dma_buffer.get()),
+                &host_res);
+    } else {
+        ctx->glUnmapBufferAEMU(
+                ctx, target,
+                buf->m_mappedOffset,
+                buf->m_mappedLength,
+                buf->m_mappedAccess,
+                (void*)((char*)buf->m_fixedBuffer.ptr() + buf->m_mappedOffset),
+                &host_res);
+    }
 
     buf->m_mapped = false;
     buf->m_mappedAccess = 0;
@@ -3862,6 +4040,8 @@
                             &maxIndex);
     }
 
+    if (count == 0) return;
+
     bool adjustIndices = true;
     if (ctx->m_state->currentIndexVbo() != 0) {
         if (!has_client_vertex_arrays) {
@@ -3953,6 +4133,8 @@
                             &maxIndex);
     }
 
+    if (count == 0) return;
+
     bool adjustIndices = true;
     if (ctx->m_state->currentIndexVbo() != 0) {
         if (!has_client_vertex_arrays) {
@@ -4021,9 +4203,9 @@
         retval);
 
     RET_AND_SET_ERROR_IF(
-        name == GL_VENDOR ||
-        name == GL_RENDERER ||
-        name == GL_VERSION ||
+        (name == GL_VENDOR ||
+         name == GL_RENDERER ||
+         name == GL_VERSION) &&
         index != 0,
         GL_INVALID_VALUE,
         retval);
@@ -4522,9 +4704,8 @@
     // Phase 1: create a ShaderData and initialize with replaceSamplerExternalWith2D()
     uint32_t spDataId = ctx->m_shared->addNewShaderProgramData();
     ShaderProgramData* spData = ctx->m_shared->getShaderProgramDataById(spDataId);
-    ShaderData* sData = spData->shaderData;
 
-    if (!replaceSamplerExternalWith2D(str, sData)) {
+    if (!replaceSamplerExternalWith2D(str, &spData->shaderData)) {
         delete [] str;
         ctx->setError(GL_OUT_OF_MEMORY);
         ctx->m_shared->deleteShaderProgramDataById(spDataId);
diff --git a/system/GLESv2_enc/GL2Encoder.h b/system/GLESv2_enc/GL2Encoder.h
index 3018622..5b51f7b 100644
--- a/system/GLESv2_enc/GL2Encoder.h
+++ b/system/GLESv2_enc/GL2Encoder.h
@@ -108,12 +108,24 @@
     GLint m_num_compressedTextureFormats;
     GLint *getCompressedTextureFormats();
 
+    GLint m_max_combinedTextureImageUnits;
+    GLint m_max_vertexTextureImageUnits;
+    GLint m_max_textureImageUnits;
     GLint m_max_cubeMapTextureSize;
     GLint m_max_renderBufferSize;
     GLint m_max_textureSize;
     GLint m_max_3d_textureSize;
     GLint m_max_vertexAttribStride;
 
+    GLint m_max_transformFeedbackSeparateAttribs;
+    GLint m_max_uniformBufferBindings;
+    GLint m_max_colorAttachments;
+    GLint m_max_drawBuffers;
+
+    GLint m_max_atomicCounterBufferBindings;
+    GLint m_max_shaderStorageBufferBindings;
+    GLint m_max_vertexAttribBindings;
+
     GLuint m_ssbo_offset_align;
     GLuint m_ubo_offset_align;
 
@@ -402,6 +414,9 @@
     static void* s_glMapBufferOES(void* self, GLenum target, GLenum access);
     static GLboolean s_glUnmapBufferOES(void* self, GLenum target);
     static void* s_glMapBufferRange(void* self, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+    static void* s_glMapBufferRangeAEMUImpl(GL2Encoder* ctx, GLenum target,
+                                            GLintptr offset, GLsizeiptr length,
+                                            GLbitfield access, BufferData* buf);
     static GLboolean s_glUnmapBuffer(void* self, GLenum target);
     static void s_glFlushMappedBufferRange(void* self, GLenum target, GLintptr offset, GLsizeiptr length);
 
diff --git a/system/GLESv2_enc/gl2_client_context.cpp b/system/GLESv2_enc/gl2_client_context.cpp
index 9eb4ac4..7da3e33 100644
--- a/system/GLESv2_enc/gl2_client_context.cpp
+++ b/system/GLESv2_enc/gl2_client_context.cpp
@@ -421,6 +421,8 @@
 	glGetFramebufferParameteriv = (glGetFramebufferParameteriv_client_proc_t) getProc("glGetFramebufferParameteriv", userData);
 	glGetTexLevelParameterfv = (glGetTexLevelParameterfv_client_proc_t) getProc("glGetTexLevelParameterfv", userData);
 	glGetTexLevelParameteriv = (glGetTexLevelParameteriv_client_proc_t) getProc("glGetTexLevelParameteriv", userData);
+	glMapBufferRangeDMA = (glMapBufferRangeDMA_client_proc_t) getProc("glMapBufferRangeDMA", userData);
+	glUnmapBufferDMA = (glUnmapBufferDMA_client_proc_t) getProc("glUnmapBufferDMA", userData);
 	return 0;
 }
 
diff --git a/system/GLESv2_enc/gl2_client_context.h b/system/GLESv2_enc/gl2_client_context.h
index 6616e53..e2400a9 100644
--- a/system/GLESv2_enc/gl2_client_context.h
+++ b/system/GLESv2_enc/gl2_client_context.h
@@ -421,6 +421,8 @@
 	glGetFramebufferParameteriv_client_proc_t glGetFramebufferParameteriv;
 	glGetTexLevelParameterfv_client_proc_t glGetTexLevelParameterfv;
 	glGetTexLevelParameteriv_client_proc_t glGetTexLevelParameteriv;
+	glMapBufferRangeDMA_client_proc_t glMapBufferRangeDMA;
+	glUnmapBufferDMA_client_proc_t glUnmapBufferDMA;
 	virtual ~gl2_client_context_t() {}
 
 	typedef gl2_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
diff --git a/system/GLESv2_enc/gl2_client_proc.h b/system/GLESv2_enc/gl2_client_proc.h
index 8c88678..8829c58 100644
--- a/system/GLESv2_enc/gl2_client_proc.h
+++ b/system/GLESv2_enc/gl2_client_proc.h
@@ -420,6 +420,8 @@
 typedef void (gl2_APIENTRY *glGetFramebufferParameteriv_client_proc_t) (void * ctx, GLenum, GLenum, GLint*);
 typedef void (gl2_APIENTRY *glGetTexLevelParameterfv_client_proc_t) (void * ctx, GLenum, GLint, GLenum, GLfloat*);
 typedef void (gl2_APIENTRY *glGetTexLevelParameteriv_client_proc_t) (void * ctx, GLenum, GLint, GLenum, GLint*);
+typedef void (gl2_APIENTRY *glMapBufferRangeDMA_client_proc_t) (void * ctx, GLenum, GLintptr, GLsizeiptr, GLbitfield, uint64_t);
+typedef void (gl2_APIENTRY *glUnmapBufferDMA_client_proc_t) (void * ctx, GLenum, GLintptr, GLsizeiptr, GLbitfield, uint64_t, GLboolean*);
 
 
 #endif
diff --git a/system/GLESv2_enc/gl2_enc.cpp b/system/GLESv2_enc/gl2_enc.cpp
index f42e7ba..d5ae4b5 100644
--- a/system/GLESv2_enc/gl2_enc.cpp
+++ b/system/GLESv2_enc/gl2_enc.cpp
@@ -8,6 +8,8 @@
 #include "gl2_enc.h"
 
 
+#include <vector>
+
 #include <stdio.h>
 
 namespace {
@@ -3028,8 +3030,7 @@
 	if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 	if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 
-    // TODO: make this part of autogenerated pipe code.
-    // b/79208762
+	// TODO: emugen produces bad code here, see b/79208762
 	stream->readbackPixels(self, width, height, format, type, pixels);
 
 	if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
@@ -11043,6 +11044,78 @@
 	}
 }
 
+void glMapBufferRangeDMA_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr)
+{
+
+	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+	IOStream *stream = ctx->m_stream;
+	ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+	bool useChecksum = checksumCalculator->getVersion() > 0;
+
+	 unsigned char *ptr;
+	 unsigned char *buf;
+	 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 8;
+	 const size_t checksumSize = checksumCalculator->checksumByteSize();
+	 const size_t totalSize = sizeWithoutChecksum + checksumSize;
+	buf = stream->alloc(totalSize);
+	ptr = buf;
+	int tmp = OP_glMapBufferRangeDMA;memcpy(ptr, &tmp, 4); ptr += 4;
+	memcpy(ptr, &totalSize, 4);  ptr += 4;
+
+		memcpy(ptr, &target, 4); ptr += 4;
+		memcpy(ptr, &offset, 4); ptr += 4;
+		memcpy(ptr, &length, 4); ptr += 4;
+		memcpy(ptr, &access, 4); ptr += 4;
+		memcpy(ptr, &paddr, 8); ptr += 8;
+
+	if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+	if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glUnmapBufferDMA_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr, GLboolean* out_res)
+{
+
+	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+	IOStream *stream = ctx->m_stream;
+	ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+	bool useChecksum = checksumCalculator->getVersion() > 0;
+
+	const unsigned int __size_out_res =  (sizeof(GLboolean));
+	 unsigned char *ptr;
+	 unsigned char *buf;
+	 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 8 + 0 + 1*4;
+	 const size_t checksumSize = checksumCalculator->checksumByteSize();
+	 const size_t totalSize = sizeWithoutChecksum + checksumSize;
+	buf = stream->alloc(totalSize);
+	ptr = buf;
+	int tmp = OP_glUnmapBufferDMA;memcpy(ptr, &tmp, 4); ptr += 4;
+	memcpy(ptr, &totalSize, 4);  ptr += 4;
+
+		memcpy(ptr, &target, 4); ptr += 4;
+		memcpy(ptr, &offset, 4); ptr += 4;
+		memcpy(ptr, &length, 4); ptr += 4;
+		memcpy(ptr, &access, 4); ptr += 4;
+		memcpy(ptr, &paddr, 8); ptr += 8;
+	*(unsigned int *)(ptr) = __size_out_res; ptr += 4;
+
+	if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+	if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+	stream->readback(out_res, __size_out_res);
+	if (useChecksum) checksumCalculator->addBuffer(out_res, __size_out_res);
+	if (useChecksum) {
+		unsigned char *checksumBufPtr = NULL;
+		unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
+		if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
+		stream->readback(checksumBufPtr, checksumSize);
+		if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
+			ALOGE("glUnmapBufferDMA: GL communication error, please report this issue to b.android.com.\n");
+			abort();
+		}
+	}
+}
+
 }  // namespace
 
 gl2_encoder_context_t::gl2_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
@@ -11461,5 +11534,7 @@
 	this->glGetFramebufferParameteriv = &glGetFramebufferParameteriv_enc;
 	this->glGetTexLevelParameterfv = &glGetTexLevelParameterfv_enc;
 	this->glGetTexLevelParameteriv = &glGetTexLevelParameteriv_enc;
+	this->glMapBufferRangeDMA = &glMapBufferRangeDMA_enc;
+	this->glUnmapBufferDMA = &glUnmapBufferDMA_enc;
 }
 
diff --git a/system/GLESv2_enc/gl2_entry.cpp b/system/GLESv2_enc/gl2_entry.cpp
index 5713921..f60eb44 100644
--- a/system/GLESv2_enc/gl2_entry.cpp
+++ b/system/GLESv2_enc/gl2_entry.cpp
@@ -416,6 +416,8 @@
 	void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint* params);
 	void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat* params);
 	void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint* params);
+	void glMapBufferRangeDMA(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr);
+	void glUnmapBufferDMA(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr, GLboolean* out_res);
 };
 
 #ifndef GET_CONTEXT
@@ -2927,3 +2929,15 @@
 	ctx->glGetTexLevelParameteriv(ctx, target, level, pname, params);
 }
 
+void glMapBufferRangeDMA(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr)
+{
+	GET_CONTEXT;
+	ctx->glMapBufferRangeDMA(ctx, target, offset, length, access, paddr);
+}
+
+void glUnmapBufferDMA(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr, GLboolean* out_res)
+{
+	GET_CONTEXT;
+	ctx->glUnmapBufferDMA(ctx, target, offset, length, access, paddr, out_res);
+}
+
diff --git a/system/GLESv2_enc/gl2_opcodes.h b/system/GLESv2_enc/gl2_opcodes.h
index 497ebfb..2affe0e 100644
--- a/system/GLESv2_enc/gl2_opcodes.h
+++ b/system/GLESv2_enc/gl2_opcodes.h
@@ -414,7 +414,9 @@
 #define OP_glGetFramebufferParameteriv 					2456
 #define OP_glGetTexLevelParameterfv 					2457
 #define OP_glGetTexLevelParameteriv 					2458
-#define OP_last 					2459
+#define OP_glMapBufferRangeDMA 					2459
+#define OP_glUnmapBufferDMA 					2460
+#define OP_last 					2461
 
 
 #endif
diff --git a/system/OpenglSystemCommon/Android.mk b/system/OpenglSystemCommon/Android.mk
index 9305119..e25e97d 100644
--- a/system/OpenglSystemCommon/Android.mk
+++ b/system/OpenglSystemCommon/Android.mk
@@ -3,13 +3,40 @@
 $(call emugl-begin-shared-library,libOpenglSystemCommon)
 $(call emugl-import,libGLESv1_enc libGLESv2_enc lib_renderControl_enc)
 
+ifeq (true,$(BUILD_EMULATOR_VULKAN))
+$(call emugl-import,libvulkan_enc)
+endif
+
 LOCAL_SRC_FILES := \
-    goldfish_dma.cpp \
     FormatConversions.cpp \
     HostConnection.cpp \
-    ProcessPipe.cpp    \
     QemuPipeStream.cpp \
-    ThreadInfo.cpp
+    ProcessPipe.cpp    \
+
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+LOCAL_SRC_FILES += \
+    ThreadInfo_host.cpp \
+
+else
+
+ifeq (true,$(BUILD_EMULATOR_VULKAN))
+
+LOCAL_HEADER_LIBRARIES += vulkan_headers
+
+endif
+
+LOCAL_SRC_FILES += \
+    ThreadInfo.cpp \
+
+endif
+
+ifneq ($(filter virgl, $(BOARD_GPU_DRIVERS)),)
+LOCAL_CFLAGS += -DVIRTIO_GPU
+LOCAL_SRC_FILES += VirtioGpuStream.cpp
+LOCAL_C_INCLUDES += external/libdrm external/minigbm/cros_gralloc
+LOCAL_SHARED_LIBRARIES += libdrm
+endif
 
 ifdef IS_AT_LEAST_OPD1
 LOCAL_HEADER_LIBRARIES += libnativebase_headers
@@ -24,4 +51,8 @@
 
 $(call emugl-export,C_INCLUDES,$(LOCAL_PATH) bionic/libc/private)
 
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+$(call emugl-export,SHARED_LIBRARIES,android-emu-shared)
+endif
+
 $(call emugl-end-module)
diff --git a/system/OpenglSystemCommon/CMakeLists.txt b/system/OpenglSystemCommon/CMakeLists.txt
new file mode 100644
index 0000000..28e4075
--- /dev/null
+++ b/system/OpenglSystemCommon/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/Android.mk" "5ee7d71d6652a9dae3d1de93b9ff1ac36a26a40193aa8d2604965c766d2ed8ab")
+set(OpenglSystemCommon_src FormatConversions.cpp HostConnection.cpp QemuPipeStream.cpp ProcessPipe.cpp ThreadInfo_host.cpp)
+android_add_shared_library(OpenglSystemCommon)
+target_include_directories(OpenglSystemCommon PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(OpenglSystemCommon PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN")
+target_compile_options(OpenglSystemCommon PRIVATE "-fvisibility=default")
+target_link_libraries(OpenglSystemCommon PRIVATE android-emu-shared vulkan_enc gui cutils utils log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/OpenglSystemCommon/EGLImage.h b/system/OpenglSystemCommon/EGLImage.h
index 6cb7431..a83e1ad 100644
--- a/system/OpenglSystemCommon/EGLImage.h
+++ b/system/OpenglSystemCommon/EGLImage.h
@@ -20,6 +20,9 @@
 #include <EGL/eglext.h>
 #include <GLES/gl.h>
 
+#include <hardware/hardware.h>
+#include <hardware/gralloc.h>
+
 #if PLATFORM_SDK_VERSION >= 16
 #if EMULATOR_OPENGL_POST_O >= 1
 #include <nativebase/nativebase.h>
diff --git a/system/OpenglSystemCommon/HostConnection.cpp b/system/OpenglSystemCommon/HostConnection.cpp
index 34ddef4..c14e12d 100644
--- a/system/OpenglSystemCommon/HostConnection.cpp
+++ b/system/OpenglSystemCommon/HostConnection.cpp
@@ -17,23 +17,73 @@
 
 #include "GLEncoder.h"
 #include "GL2Encoder.h"
+
+#ifdef GOLDFISH_VULKAN
+#include "VkEncoder.h"
+#else
+namespace goldfish_vk {
+struct VkEncoder {
+    VkEncoder(IOStream*) { }
+    int placeholder;
+};
+} // namespace goldfish_vk
+#endif
+
+using goldfish_vk::VkEncoder;
+
 #include "ProcessPipe.h"
 #include "QemuPipeStream.h"
 #include "TcpStream.h"
 #include "ThreadInfo.h"
 
+#include "gralloc_cb.h"
+
+#ifdef VIRTIO_GPU
+#include "VirtioGpuStream.h"
+#endif
+
 #include <cutils/log.h>
 
 #define STREAM_BUFFER_SIZE  (4*1024*1024)
 #define STREAM_PORT_NUM     22468
 
-/* Set to 1 to use a QEMU pipe, or 0 for a TCP connection */
-#define  USE_QEMU_PIPE  1
+enum HostConnectionType {
+    HOST_CONNECTION_TCP = 0,
+    HOST_CONNECTION_QEMU_PIPE = 1,
+    HOST_CONNECTION_VIRTIO_GPU = 2,
+};
+
+class GoldfishGralloc : public Gralloc
+{
+public:
+    uint32_t getHostHandle(native_handle_t const* handle)
+    {
+        return ((cb_handle_t *)handle)->hostHandle;
+    }
+
+    int getFormat(native_handle_t const* handle)
+    {
+        return ((cb_handle_t *)handle)->format;
+    }
+};
+
+class GoldfishProcessPipe : public ProcessPipe
+{
+public:
+    bool processPipeInit(renderControl_encoder_context_t *rcEnc)
+    {
+        return ::processPipeInit(rcEnc);
+    }
+};
+
+static GoldfishGralloc m_goldfishGralloc;
+static GoldfishProcessPipe m_goldfishProcessPipe;
 
 HostConnection::HostConnection() :
     m_stream(NULL),
     m_glEnc(NULL),
     m_gl2Enc(NULL),
+    m_vkEnc(NULL),
     m_rcEnc(NULL),
     m_checksumHelper(),
     m_glExtensions(),
@@ -57,7 +107,7 @@
 HostConnection *HostConnection::getWithThreadInfo(EGLThreadInfo* tinfo) {
 
     /* TODO: Make this configurable with a system property */
-    const int useQemuPipe = USE_QEMU_PIPE;
+    const enum HostConnectionType connType = HOST_CONNECTION_VIRTIO_GPU;
 
     // Get thread info
     if (!tinfo) {
@@ -70,38 +120,65 @@
             return NULL;
         }
 
-        if (useQemuPipe) {
-            QemuPipeStream *stream = new QemuPipeStream(STREAM_BUFFER_SIZE);
-            if (!stream) {
-                ALOGE("Failed to create QemuPipeStream for host connection!!!\n");
-                delete con;
-                return NULL;
+        switch (connType) {
+            default:
+            case HOST_CONNECTION_QEMU_PIPE: {
+                QemuPipeStream *stream = new QemuPipeStream(STREAM_BUFFER_SIZE);
+                if (!stream) {
+                    ALOGE("Failed to create QemuPipeStream for host connection!!!\n");
+                    delete con;
+                    return NULL;
+                }
+                if (stream->connect() < 0) {
+                    ALOGE("Failed to connect to host (QemuPipeStream)!!!\n");
+                    delete stream;
+                    delete con;
+                    return NULL;
+                }
+                con->m_stream = stream;
+                con->m_grallocHelper = &m_goldfishGralloc;
+                con->m_processPipe = &m_goldfishProcessPipe;
+                break;
             }
-            if (stream->connect() < 0) {
-                ALOGE("Failed to connect to host (QemuPipeStream)!!!\n");
-                delete stream;
-                delete con;
-                return NULL;
-            }
-            con->m_stream = stream;
-            con->m_pipeFd = stream->getSocket();
-        }
-        else /* !useQemuPipe */
-        {
-            TcpStream *stream = new TcpStream(STREAM_BUFFER_SIZE);
-            if (!stream) {
-                ALOGE("Failed to create TcpStream for host connection!!!\n");
-                delete con;
-                return NULL;
-            }
+            case HOST_CONNECTION_TCP: {
+                TcpStream *stream = new TcpStream(STREAM_BUFFER_SIZE);
+                if (!stream) {
+                    ALOGE("Failed to create TcpStream for host connection!!!\n");
+                    delete con;
+                    return NULL;
+                }
 
-            if (stream->connect("10.0.2.2", STREAM_PORT_NUM) < 0) {
-                ALOGE("Failed to connect to host (TcpStream)!!!\n");
-                delete stream;
-                delete con;
-                return NULL;
+                if (stream->connect("10.0.2.2", STREAM_PORT_NUM) < 0) {
+                    ALOGE("Failed to connect to host (TcpStream)!!!\n");
+                    delete stream;
+                    delete con;
+                    return NULL;
+                }
+                con->m_stream = stream;
+                con->m_grallocHelper = &m_goldfishGralloc;
+                con->m_processPipe = &m_goldfishProcessPipe;
+                break;
             }
-            con->m_stream = stream;
+#ifdef VIRTIO_GPU
+            case HOST_CONNECTION_VIRTIO_GPU: {
+                VirtioGpuStream *stream = new VirtioGpuStream(STREAM_BUFFER_SIZE);
+                if (!stream) {
+                    ALOGE("Failed to create VirtioGpu for host connection!!!\n");
+                    delete con;
+                    return NULL;
+                }
+                if (stream->connect() < 0) {
+                    ALOGE("Failed to connect to host (VirtioGpu)!!!\n");
+                    delete stream;
+                    delete con;
+                    return NULL;
+                }
+                con->m_stream = stream;
+                con->m_grallocHelper = stream->getGralloc();
+                con->m_processPipe = stream->getProcessPipe();
+                break;
+            }
+#endif
         }
 
         // send zero 'clientFlags' to the host.
@@ -110,7 +187,8 @@
         *pClientFlags = 0;
         con->m_stream->commitBuffer(sizeof(unsigned int));
 
-        ALOGD("HostConnection::get() New Host Connection established %p, tid %d\n", con, gettid());
+        ALOGD("HostConnection::get() New Host Connection established %p, tid %d\n",
+              con, getCurrentThreadId());
         tinfo->hostConn = con;
     }
 
@@ -135,7 +213,8 @@
 {
     if (!m_glEnc) {
         m_glEnc = new GLEncoder(m_stream, checksumHelper());
-        DBG("HostConnection::glEncoder new encoder %p, tid %d", m_glEnc, gettid());
+        DBG("HostConnection::glEncoder new encoder %p, tid %d",
+            m_glEnc, getCurrentThreadId());
         m_glEnc->setContextAccessor(s_getGLContext);
     }
     return m_glEnc;
@@ -145,13 +224,22 @@
 {
     if (!m_gl2Enc) {
         m_gl2Enc = new GL2Encoder(m_stream, checksumHelper());
-        DBG("HostConnection::gl2Encoder new encoder %p, tid %d", m_gl2Enc, gettid());
+        DBG("HostConnection::gl2Encoder new encoder %p, tid %d",
+            m_gl2Enc, getCurrentThreadId());
         m_gl2Enc->setContextAccessor(s_getGL2Context);
         m_gl2Enc->setNoHostError(m_noHostError);
     }
     return m_gl2Enc;
 }
 
+VkEncoder *HostConnection::vkEncoder()
+{
+    if (!m_vkEnc) {
+        m_vkEnc = new VkEncoder(m_stream);
+    }
+    return m_vkEnc;
+}
+
 ExtendedRCEncoderContext *HostConnection::rcEncoder()
 {
     if (!m_rcEnc) {
@@ -161,7 +249,10 @@
         queryAndSetDmaImpl(m_rcEnc);
         queryAndSetGLESMaxVersion(m_rcEnc);
         queryAndSetNoErrorState(m_rcEnc);
-        processPipeInit(m_rcEnc);
+        queryAndSetHostCompositionImpl(m_rcEnc);
+        if (m_processPipe) {
+            m_processPipe->processPipeInit(m_rcEnc);
+        }
     }
     return m_rcEnc;
 }
@@ -212,6 +303,17 @@
     return m_glExtensions;
 }
 
+void HostConnection::queryAndSetHostCompositionImpl(ExtendedRCEncoderContext *rcEnc) {
+    const std::string& glExtensions = queryGLExtensions(rcEnc);
+    ALOGD("HostComposition ext %s", glExtensions.c_str());
+    if (glExtensions.find(kHostCompositionV1) != std::string::npos) {
+        rcEnc->setHostComposition(HOST_COMPOSITION_V1);
+    }
+    else {
+        rcEnc->setHostComposition(HOST_COMPOSITION_NONE);
+    }
+}
+
 void HostConnection::setChecksumHelper(ExtendedRCEncoderContext *rcEnc) {
     const std::string& glExtensions = queryGLExtensions(rcEnc);
     // check the host supported version
diff --git a/system/OpenglSystemCommon/HostConnection.h b/system/OpenglSystemCommon/HostConnection.h
index 2b49857..ac2f330 100644
--- a/system/OpenglSystemCommon/HostConnection.h
+++ b/system/OpenglSystemCommon/HostConnection.h
@@ -21,6 +21,7 @@
 #include "ChecksumCalculator.h"
 #include "goldfish_dma.h"
 
+#include <cutils/native_handle.h>
 #include <string>
 
 class GLEncoder;
@@ -28,6 +29,10 @@
 class GL2Encoder;
 struct gl2_client_context_t;
 
+namespace goldfish_vk {
+class VkEncoder;
+}
+
 // SyncImpl determines the presence of host/guest OpenGL fence sync
 // capabilities. It corresponds exactly to EGL_ANDROID_native_fence_sync
 // capability, but for the emulator, we need to make sure that
@@ -71,6 +76,12 @@
 static const char kGLESMaxVersion_3_1[] = "ANDROID_EMU_gles_max_version_3_1";
 static const char kGLESMaxVersion_3_2[] = "ANDROID_EMU_gles_max_version_3_2";
 
+enum HostComposition {
+    HOST_COMPOSITION_NONE = 0,
+    HOST_COMPOSITION_V1,
+};
+static const char kHostCompositionV1[] = "ANDROID_EMU_host_composition_v1";
+
 // No querying errors from host extension
 static const char kGLESNoHostError[] = "ANDROID_EMU_gles_no_host_error";
 
@@ -84,8 +95,12 @@
         }
     void setSyncImpl(SyncImpl syncImpl) { m_syncImpl = syncImpl; }
     void setDmaImpl(DmaImpl dmaImpl) { m_dmaImpl = dmaImpl; }
+    void setHostComposition(HostComposition hostComposition) {
+        m_hostComposition = hostComposition; }
     bool hasNativeSync() const { return m_syncImpl >= SYNC_IMPL_NATIVE_SYNC_V2; }
     bool hasNativeSyncV3() const { return m_syncImpl >= SYNC_IMPL_NATIVE_SYNC_V3; }
+    bool hasHostCompositionV1() const {
+        return m_hostComposition == HOST_COMPOSITION_V1; }
     DmaImpl getDmaVersion() const { return m_dmaImpl; }
     void bindDmaContext(struct goldfish_dma_context* cxt) { m_dmaCxt = cxt; }
     virtual uint64_t lockAndWriteDma(void* data, uint32_t size) {
@@ -98,7 +113,7 @@
         goldfish_dma_lock(m_dmaCxt);
         goldfish_dma_write(m_dmaCxt, data, size);
         uint64_t paddr = goldfish_dma_guest_paddr(m_dmaCxt);
-        ALOGV("%s: paddr=0x%llx", __FUNCTION__, paddr);
+        ALOGV("%s: paddr=0x%llx", __FUNCTION__, (unsigned long long)paddr);
         return paddr;
     }
     void setGLESMaxVersion(GLESMaxVersion ver) { m_glesMaxVersion = ver; }
@@ -106,10 +121,26 @@
 private:
     SyncImpl m_syncImpl;
     DmaImpl m_dmaImpl;
+    HostComposition m_hostComposition;
     struct goldfish_dma_context* m_dmaCxt;
     GLESMaxVersion m_glesMaxVersion;
 };
 
+// Abstraction for gralloc handle conversion
+class Gralloc {
+public:
+    virtual uint32_t getHostHandle(native_handle_t const* handle) = 0;
+    virtual int getFormat(native_handle_t const* handle) = 0;
+    virtual ~Gralloc() {}
+};
+
+// Abstraction for process pipe helper
+class ProcessPipe {
+public:
+    virtual bool processPipeInit(renderControl_encoder_context_t *rcEnc) = 0;
+    virtual ~ProcessPipe() {}
+};
+
 struct EGLThreadInfo;
 
 class HostConnection
@@ -122,8 +153,10 @@
 
     GLEncoder *glEncoder();
     GL2Encoder *gl2Encoder();
+    goldfish_vk::VkEncoder *vkEncoder();
     ExtendedRCEncoderContext *rcEncoder();
     ChecksumCalculator *checksumHelper() { return &m_checksumHelper; }
+    Gralloc *grallocHelper() { return m_grallocHelper; }
 
     void flush() {
         if (m_stream) {
@@ -137,8 +170,6 @@
 
     bool isGrallocOnly() const { return m_grallocOnly; }
 
-    int getPipeFd() const { return m_pipeFd; }
-
 private:
     HostConnection();
     static gl_client_context_t  *s_getGLContext();
@@ -152,16 +183,19 @@
     void queryAndSetDmaImpl(ExtendedRCEncoderContext *rcEnc);
     void queryAndSetGLESMaxVersion(ExtendedRCEncoderContext *rcEnc);
     void queryAndSetNoErrorState(ExtendedRCEncoderContext *rcEnc);
+    void queryAndSetHostCompositionImpl(ExtendedRCEncoderContext *rcEnc);
 
 private:
     IOStream *m_stream;
     GLEncoder   *m_glEnc;
     GL2Encoder  *m_gl2Enc;
+    goldfish_vk::VkEncoder  *m_vkEnc;
     ExtendedRCEncoderContext *m_rcEnc;
     ChecksumCalculator m_checksumHelper;
+    Gralloc *m_grallocHelper;
+    ProcessPipe *m_processPipe;
     std::string m_glExtensions;
     bool m_grallocOnly;
-    int m_pipeFd;
     bool m_noHostError;
 };
 
diff --git a/system/OpenglSystemCommon/ProcessPipe.cpp b/system/OpenglSystemCommon/ProcessPipe.cpp
index 127f273..08e9571 100644
--- a/system/OpenglSystemCommon/ProcessPipe.cpp
+++ b/system/OpenglSystemCommon/ProcessPipe.cpp
@@ -19,8 +19,9 @@
 
 #include <cutils/log.h>
 #include <pthread.h>
+#include <errno.h>
 
-static int                sProcPipe = 0;
+static QEMU_PIPE_HANDLE   sProcPipe = 0;
 static pthread_once_t     sProcPipeOnce = PTHREAD_ONCE_INIT;
 // sProcUID is a unique ID per process assigned by the host.
 // It is different from getpid().
@@ -35,7 +36,7 @@
 // host.
 static void processPipeInitOnce() {
     sProcPipe = qemu_pipe_open("GLProcessPipe");
-    if (sProcPipe < 0) {
+    if (!qemu_pipe_valid(sProcPipe)) {
         sProcPipe = 0;
         ALOGW("Process pipe failed");
         return;
@@ -44,12 +45,13 @@
     int32_t confirmInt = 100;
     ssize_t stat = 0;
     do {
-        stat = ::write(sProcPipe, (const char*)&confirmInt,
+        stat =
+            qemu_pipe_write(sProcPipe, (const char*)&confirmInt,
                 sizeof(confirmInt));
     } while (stat < 0 && errno == EINTR);
 
     if (stat != sizeof(confirmInt)) { // failed
-        close(sProcPipe);
+        qemu_pipe_close(sProcPipe);
         sProcPipe = 0;
         ALOGW("Process pipe failed");
         return;
@@ -57,12 +59,13 @@
 
     // Ask the host for per-process unique ID
     do {
-        stat = ::read(sProcPipe, (char*)&sProcUID,
-                      sizeof(sProcUID));
+        stat =
+            qemu_pipe_read(sProcPipe, (char*)&sProcUID,
+                sizeof(sProcUID));
     } while (stat < 0 && errno == EINTR);
 
     if (stat != sizeof(sProcUID)) {
-        close(sProcPipe);
+        qemu_pipe_close(sProcPipe);
         sProcPipe = 0;
         sProcUID = 0;
         ALOGW("Process pipe failed");
diff --git a/system/OpenglSystemCommon/QemuPipeStream.cpp b/system/OpenglSystemCommon/QemuPipeStream.cpp
index 58703bf..cfe0fbd 100644
--- a/system/OpenglSystemCommon/QemuPipeStream.cpp
+++ b/system/OpenglSystemCommon/QemuPipeStream.cpp
@@ -14,8 +14,8 @@
 * limitations under the License.
 */
 #include "QemuPipeStream.h"
-#include "qemu_pipe.h"
 
+#include <cutils/log.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -24,13 +24,13 @@
 
 QemuPipeStream::QemuPipeStream(size_t bufSize) :
     IOStream(bufSize),
-    m_sock(-1),
+    m_sock((QEMU_PIPE_HANDLE)(-1)),
     m_bufsize(bufSize),
     m_buf(NULL)
 {
 }
 
-QemuPipeStream::QemuPipeStream(int sock, size_t bufSize) :
+QemuPipeStream::QemuPipeStream(QEMU_PIPE_HANDLE sock, size_t bufSize) :
     IOStream(bufSize),
     m_sock(sock),
     m_bufsize(bufSize),
@@ -40,9 +40,9 @@
 
 QemuPipeStream::~QemuPipeStream()
 {
-    if (m_sock >= 0) {
+    if (valid()) {
         flush();
-        ::close(m_sock);
+        qemu_pipe_close(m_sock);
     }
     if (m_buf != NULL) {
         free(m_buf);
@@ -52,9 +52,10 @@
 
 int QemuPipeStream::connect(void)
 {
-     m_sock = qemu_pipe_open("opengles");
+    m_sock = qemu_pipe_open("opengles");
     if (!valid()) {
-        ALOGE("%s: failed with fd %d errno %d", __FUNCTION__, m_sock, errno);
+        ALOGE("%s: failed to connect to opengles pipe", __FUNCTION__);
+        qemu_pipe_print_error(m_sock);
         return -1;
     }
     return 0;
@@ -72,7 +73,7 @@
             m_buf = p;
             m_bufsize = allocSize;
         } else {
-            ERR("realloc (%d) failed\n", allocSize);
+            ERR("realloc (%zu) failed\n", allocSize);
             free(m_buf);
             m_buf = NULL;
             m_bufsize = 0;
@@ -95,7 +96,7 @@
        if (len>0) {
             // If len is non-zero, buf must not be NULL. Otherwise the pipe would be
             // in a corrupted state, which is lethal for the emulator.
-           ERR("QemuPipeStream::writeFully failed, buf=NULL, len %d,"
+           ERR("QemuPipeStream::writeFully failed, buf=NULL, len %zu,"
                    " lethal error, exiting", len);
            abort();
        }
@@ -106,7 +107,7 @@
     int retval = 0;
 
     while (res > 0) {
-        ssize_t stat = ::write(m_sock, (const char *)(buf) + (len - res), res);
+        ssize_t stat = qemu_pipe_write(m_sock, (const char *)(buf) + (len - res), res);
         if (stat > 0) {
             res -= stat;
             continue;
@@ -116,7 +117,7 @@
             retval = -1;
             break;
         }
-        if (errno == EINTR) {
+        if (qemu_pipe_try_again()) {
             continue;
         }
         retval =  stat;
@@ -128,7 +129,7 @@
     return retval;
 }
 
-int QemuPipeStream::getSocket() const {
+QEMU_PIPE_HANDLE QemuPipeStream::getSocket() const {
     return m_sock;
 }
 
@@ -148,12 +149,12 @@
     }
     size_t res = len;
     while (res > 0) {
-        ssize_t stat = ::read(m_sock, (char *)(buf) + len - res, res);
+        ssize_t stat = qemu_pipe_read(m_sock, (char *)(buf) + len - res, res);
         if (stat == 0) {
             // client shutdown;
             return NULL;
         } else if (stat < 0) {
-            if (errno == EINTR) {
+            if (qemu_pipe_try_again()) {
                 continue;
             } else {
                 ERR("QemuPipeStream::readFully failed (buf %p, len %zu"
@@ -195,7 +196,7 @@
     char* p = (char *)buf;
     int ret = 0;
     while(len > 0) {
-        int res = ::read(m_sock, p, len);
+        int res = qemu_pipe_read(m_sock, p, len);
         if (res > 0) {
             p += res;
             ret += res;
@@ -205,7 +206,7 @@
         if (res == 0) { /* EOF */
              break;
         }
-        if (errno == EINTR)
+        if (qemu_pipe_try_again())
             continue;
 
         /* A real error */
diff --git a/system/OpenglSystemCommon/QemuPipeStream.h b/system/OpenglSystemCommon/QemuPipeStream.h
index 15f74e6..0884d57 100644
--- a/system/OpenglSystemCommon/QemuPipeStream.h
+++ b/system/OpenglSystemCommon/QemuPipeStream.h
@@ -23,6 +23,8 @@
 #include <stdlib.h>
 #include "IOStream.h"
 
+#include "qemu_pipe.h"
+
 class QemuPipeStream : public IOStream {
 public:
     typedef enum { ERR_INVALID_SOCKET = -1000 } QemuPipeStreamError;
@@ -36,17 +38,17 @@
     virtual const unsigned char *readFully( void *buf, size_t len);
     virtual const unsigned char *read( void *buf, size_t *inout_len);
 
-    bool valid() { return m_sock >= 0; }
+    bool valid() { return qemu_pipe_valid(m_sock); }
     int recv(void *buf, size_t len);
 
     virtual int writeFully(const void *buf, size_t len);
 
-    int getSocket() const;
+    QEMU_PIPE_HANDLE getSocket() const;
 private:
-    int m_sock;
+    QEMU_PIPE_HANDLE m_sock;
     size_t m_bufsize;
     unsigned char *m_buf;
-    QemuPipeStream(int sock, size_t bufSize);
+    QemuPipeStream(QEMU_PIPE_HANDLE sock, size_t bufSize);
 };
 
 #endif
diff --git a/system/OpenglSystemCommon/ThreadInfo.cpp b/system/OpenglSystemCommon/ThreadInfo.cpp
index 425904e..31a8fe9 100644
--- a/system/OpenglSystemCommon/ThreadInfo.cpp
+++ b/system/OpenglSystemCommon/ThreadInfo.cpp
@@ -16,6 +16,9 @@
 #include "ThreadInfo.h"
 #include "cutils/threads.h"
 
+#include <bionic_tls.h>
+#include <pthread.h>
+
 thread_store_t s_tls = THREAD_STORE_INITIALIZER;
 
 static bool sDefaultTlsDestructorCallback(__attribute__((__unused__)) void* ptr) {
@@ -26,7 +29,10 @@
 static void tlsDestruct(void *ptr)
 {
     sTlsDestructorCallback(ptr);
-    if (ptr) {
+    if (ptr
+#ifdef __ANDROID__
+         && ((void **)__get_tls())[TLS_SLOT_OPENGL]) {
+#endif
         EGLThreadInfo *ti = (EGLThreadInfo *)ptr;
         delete ti->hostConn;
         delete ti;
@@ -51,3 +57,21 @@
 
     return ti;
 }
+
+EGLThreadInfo* getEGLThreadInfo() {
+#ifdef __ANDROID__
+    EGLThreadInfo *tInfo =
+        (EGLThreadInfo *)(((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL]);
+    if (!tInfo) {
+        tInfo = goldfish_get_egl_tls();
+        ((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL] = (uintptr_t)tInfo;
+    }
+    return tInfo;
+#else
+    return goldfish_get_egl_tls();
+#endif
+}
+
+int32_t getCurrentThreadId() {
+    return (int32_t)gettid();
+}
diff --git a/system/OpenglSystemCommon/ThreadInfo.h b/system/OpenglSystemCommon/ThreadInfo.h
index 57fd5ef..7d2260a 100644
--- a/system/OpenglSystemCommon/ThreadInfo.h
+++ b/system/OpenglSystemCommon/ThreadInfo.h
@@ -17,9 +17,9 @@
 #define _THREAD_INFO_H
 
 #include "HostConnection.h"
-#include <pthread.h>
 
-#include <bionic_tls.h>
+#include <inttypes.h>
+
 struct EGLContext_t;
 
 struct EGLThreadInfo
@@ -31,24 +31,13 @@
     int           eglError;
 };
 
-
 typedef bool (*tlsDtorCallback)(void*);
 void setTlsDestructor(tlsDtorCallback);
 
 extern "C" __attribute__((visibility("default"))) EGLThreadInfo *goldfish_get_egl_tls();
 
-inline EGLThreadInfo* getEGLThreadInfo() {
-#ifdef __ANDROID__
-    EGLThreadInfo *tInfo =
-        (EGLThreadInfo *)(((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL]);
-    if (!tInfo) {
-        tInfo = goldfish_get_egl_tls();
-        ((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL] = (uintptr_t)tInfo;
-    }
-    return tInfo;
-#else
-    return goldfish_get_egl_tls();
-#endif
-}
+EGLThreadInfo* getEGLThreadInfo();
+
+int32_t getCurrentThreadId();
 
 #endif // of _THREAD_INFO_H
diff --git a/system/OpenglSystemCommon/ThreadInfo_host.cpp b/system/OpenglSystemCommon/ThreadInfo_host.cpp
new file mode 100644
index 0000000..0379933
--- /dev/null
+++ b/system/OpenglSystemCommon/ThreadInfo_host.cpp
@@ -0,0 +1,66 @@
+// Copyright 2018 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 "ThreadInfo.h"
+
+#include "android/base/memory/LazyInstance.h"
+#include "android/base/threads/Thread.h"
+#include "android/base/threads/ThreadStore.h"
+
+using android::base::LazyInstance;
+using android::base::ThreadStoreBase;
+
+static bool sDefaultTlsDestructorCallback(__attribute__((__unused__)) void* ptr) {
+  return true;
+}
+static bool (*sTlsDestructorCallback)(void*) = sDefaultTlsDestructorCallback;
+
+void setTlsDestructor(tlsDtorCallback func) {
+    sTlsDestructorCallback = func;
+}
+
+static void doTlsDestruct(void* obj) {
+    sTlsDestructorCallback(obj);
+}
+
+class ThreadInfoStore : public ThreadStoreBase {
+public:
+    ThreadInfoStore() : ThreadStoreBase(NULL) { }
+    ~ThreadInfoStore();
+};
+
+static LazyInstance<ThreadInfoStore> sTls = LAZY_INSTANCE_INIT;
+
+ThreadInfoStore::~ThreadInfoStore() {
+    doTlsDestruct(sTls->get());
+}
+
+EGLThreadInfo *goldfish_get_egl_tls()
+{
+    EGLThreadInfo* ti = (EGLThreadInfo*)sTls->get();
+
+    if (ti) return ti;
+
+    ti = new EGLThreadInfo();
+    sTls->set(ti);
+
+    return ti;
+}
+
+EGLThreadInfo* getEGLThreadInfo() {
+    return goldfish_get_egl_tls();
+}
+
+int32_t getCurrentThreadId() {
+    return (int32_t)android::base::getCurrentThreadId();
+}
diff --git a/system/OpenglSystemCommon/VirtioGpuStream.cpp b/system/OpenglSystemCommon/VirtioGpuStream.cpp
new file mode 100644
index 0000000..f6d04d8
--- /dev/null
+++ b/system/OpenglSystemCommon/VirtioGpuStream.cpp
@@ -0,0 +1,439 @@
+/*
+ * Copyright (C) 2018 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 "VirtioGpuStream.h"
+
+#include <cros_gralloc_handle.h>
+#include <drm/virtgpu_drm.h>
+#include <xf86drm.h>
+
+#include <sys/types.h>
+#include <sys/mman.h>
+
+#include <errno.h>
+#include <unistd.h>
+
+#ifndef PAGE_SIZE
+#define PAGE_SIZE 0x1000
+#endif
+
+// In a virtual machine, there should only be one GPU
+#define RENDERNODE_MINOR 128
+
+// Maximum size of readback / response buffer in bytes
+#define MAX_CMDRESPBUF_SIZE (10*PAGE_SIZE)
+
+// Attributes use to allocate our response buffer
+// Similar to virgl's fence objects
+#define PIPE_BUFFER             0
+#define VIRGL_FORMAT_R8_UNORM   64
+#define VIRGL_BIND_CUSTOM       (1 << 17)
+
+// Conservative; see virgl_winsys.h
+#define VIRGL_MAX_CMDBUF_DWORDS (16*1024)
+#define VIRGL_MAX_CMDBUF_SIZE   (4*VIRGL_MAX_CMDBUF_DWORDS)
+
+struct VirtioGpuCmd {
+    uint32_t op;
+    uint32_t cmdSize;
+    unsigned char buf[0];
+} __attribute__((packed));
+
+uint32_t CrosGralloc::getHostHandle(native_handle_t const* handle_)
+{
+    uint32_t id = 0;
+
+    if (m_fd >= 0) {
+        cros_gralloc_handle const* handle =
+          reinterpret_cast<cros_gralloc_handle const*>(handle_);
+        drmPrimeFDToHandle(m_fd, handle->fds[0], &id);
+    }
+
+    return id;
+}
+
+int CrosGralloc::getFormat(native_handle_t const* handle)
+{
+    return ((cros_gralloc_handle *)handle)->droid_format;
+}
+
+bool VirtioGpuProcessPipe::processPipeInit(renderControl_encoder_context_t *rcEnc)
+{
+  union {
+      uint64_t proto;
+      struct {
+          int pid;
+          int tid;
+      } id;
+  } puid = {
+      .id.pid = getpid(),
+      .id.tid = gettid(),
+  };
+  rcEnc->rcSetPuid(rcEnc, puid.proto);
+  return true;
+}
+
+VirtioGpuStream::VirtioGpuStream(size_t bufSize) :
+    IOStream(0U),
+    m_fd(-1),
+    m_bufSize(bufSize),
+    m_buf(nullptr),
+    m_cmdResp_rh(0U),
+    m_cmdResp_bo(0U),
+    m_cmdResp(nullptr),
+    m_cmdRespPos(0U),
+    m_cmdPos(0U),
+    m_flushPos(0U),
+    m_allocSize(0U),
+    m_allocFlushSize(0U)
+{
+}
+
+VirtioGpuStream::~VirtioGpuStream()
+{
+    if (m_cmdResp) {
+        munmap(m_cmdResp, MAX_CMDRESPBUF_SIZE);
+    }
+
+    if (m_cmdResp_bo > 0U) {
+        drm_gem_close gem_close = {
+            .handle = m_cmdResp_bo,
+        };
+        drmIoctl(m_fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
+    }
+
+    if (m_fd >= 0) {
+        close(m_fd);
+    }
+
+    free(m_buf);
+}
+
+int VirtioGpuStream::connect()
+{
+    if (m_fd < 0) {
+        m_fd = drmOpenRender(RENDERNODE_MINOR);
+        if (m_fd < 0) {
+            ERR("%s: failed with fd %d (%s)", __func__, m_fd, strerror(errno));
+            return -1;
+        }
+    }
+
+    if (!m_cmdResp_bo) {
+        drm_virtgpu_resource_create create = {
+            .target     = PIPE_BUFFER,
+            .format     = VIRGL_FORMAT_R8_UNORM,
+            .bind       = VIRGL_BIND_CUSTOM,
+            .width      = MAX_CMDRESPBUF_SIZE,
+            .height     = 1U,
+            .depth      = 1U,
+            .array_size = 0U,
+            .size       = MAX_CMDRESPBUF_SIZE,
+            .stride     = MAX_CMDRESPBUF_SIZE,
+        };
+        int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &create);
+        if (ret) {
+            ERR("%s: failed with %d allocating command response buffer (%s)",
+                __func__, ret, strerror(errno));
+            return -1;
+        }
+        m_cmdResp_bo = create.bo_handle;
+        if (!m_cmdResp_bo) {
+            ERR("%s: no handle when allocating command response buffer",
+                __func__);
+            return -1;
+        }
+        m_cmdResp_rh = create.res_handle;
+        if (create.size != MAX_CMDRESPBUF_SIZE) {
+	    ERR("%s: command response buffer wrongly sized, create.size=%zu "
+		"!= %zu", __func__,
+		static_cast<size_t>(create.size),
+		static_cast<size_t>(MAX_CMDRESPBUF_SIZE));
+	    abort();
+	}
+    }
+
+    if (!m_cmdResp) {
+        drm_virtgpu_map map = {
+            .handle = m_cmdResp_bo,
+        };
+        int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_MAP, &map);
+        if (ret) {
+            ERR("%s: failed with %d mapping command response buffer (%s)",
+                __func__, ret, strerror(errno));
+            return -1;
+        }
+        m_cmdResp = static_cast<VirtioGpuCmd *>(mmap64(nullptr,
+                                                       MAX_CMDRESPBUF_SIZE,
+                                                       PROT_READ, MAP_SHARED,
+                                                       m_fd, map.offset));
+        if (m_cmdResp == MAP_FAILED) {
+            ERR("%s: failed with %d mmap'ing command response buffer (%s)",
+                __func__, ret, strerror(errno));
+            return -1;
+        }
+    }
+
+    m_gralloc.setFd(m_fd);
+    return 0;
+}
+
+int VirtioGpuStream::flush()
+{
+    int ret = commitBuffer(m_allocSize - m_allocFlushSize);
+    if (ret)
+        return ret;
+    m_allocFlushSize = m_allocSize;
+    return 0;
+}
+
+void *VirtioGpuStream::allocBuffer(size_t minSize)
+{
+    if (m_buf) {
+        // Try to model the alloc() calls being made by the user. They should be
+        // obeying the protocol and using alloc() for anything they don't write
+        // with writeFully(), so we can know if this alloc() is for part of a
+        // command, or not. If it is not for part of a command, we are starting
+        // a new command, and should increment m_cmdPos.
+        VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
+        if (m_allocSize + minSize > cmd->cmdSize) {
+            m_allocFlushSize = 0U;
+            m_allocSize = 0U;
+            // This might also be a convenient point to flush commands
+            if (m_cmdPos + cmd->cmdSize + minSize > m_bufSize) {
+                if (commitAll() < 0) {
+                    ERR("%s: command flush failed", __func__);
+                    m_flushPos = 0U;
+                    m_bufSize = 0U;
+                    m_cmdPos = 0U;
+                    free(m_buf);
+                    m_buf = nullptr;
+                    return nullptr;
+                }
+            } else {
+                m_cmdPos += cmd->cmdSize;
+                m_flushPos = m_cmdPos;
+            }
+        }
+    }
+
+    // Update m_allocSize here, before minSize is tampered with below
+    m_allocSize += minSize;
+
+    // Make sure anything we already have written to the buffer is retained
+    minSize += m_flushPos;
+
+    size_t allocSize = (m_bufSize < minSize ? minSize : m_bufSize);
+    if (!m_buf) {
+        m_buf = static_cast<unsigned char *>(malloc(allocSize));
+    } else if (m_bufSize < allocSize) {
+        unsigned char *p = static_cast<unsigned char *>(realloc(m_buf, allocSize));
+        if (!p) {
+            free(m_buf);
+        }
+        m_buf = p;
+    }
+    if (!m_buf) {
+        ERR("%s: alloc (%zu) failed\n", __func__, allocSize);
+        m_allocFlushSize = 0U;
+        m_allocSize = 0U;
+        m_flushPos = 0U;
+        m_bufSize = 0U;
+        m_cmdPos = 0U;
+    } else {
+        m_bufSize = allocSize;
+    }
+    if (m_flushPos == 0 && m_cmdPos == 0) {
+      // During initialization, HostConnection will send an empty command
+      // packet to check the connection is good, but it doesn't obey the usual
+      // line protocol. This is a 4 byte write to [0], which is our 'op' field,
+      // and we don't have an op=0 so it's OK. We fake up a valid length, and
+      // overload this workaround by putting the res_handle for the readback
+      // buffer in the command payload, patched in just before we submit.
+      VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
+      cmd->op = 0U;
+      cmd->cmdSize = sizeof(*cmd) + sizeof(__u32);
+    }
+    return m_buf + m_cmdPos;
+}
+
+// For us, writeFully() means to write a command without any header, directly
+// into the buffer stream. We can use the packet frame written directly to the
+// stream to verify this write is within bounds, then update the counter.
+
+int VirtioGpuStream::writeFully(const void *buf, size_t len)
+{
+    if (!valid())
+        return -1;
+
+    if (!buf) {
+        if (len > 0) {
+            // If len is non-zero, buf must not be NULL. Otherwise the pipe would
+            // be in a corrupted state, which is lethal for the emulator.
+            ERR("%s: failed, buf=NULL, len %zu, lethal error, exiting",
+                __func__, len);
+            abort();
+        }
+        return 0;
+    }
+
+    VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
+
+    if (m_flushPos < sizeof(*cmd)) {
+        ERR("%s: writeFully len %zu would overwrite command header, "
+            "cmd_pos=%zu, flush_pos=%zu, lethal error, exiting", __func__,
+            len, m_cmdPos, m_flushPos);
+        abort();
+    }
+
+    if (m_flushPos + len > cmd->cmdSize) {
+        ERR("%s: writeFully len %zu would overflow the command bounds, "
+            "cmd_pos=%zu, flush_pos=%zu, cmdsize=%zu, lethal error, exiting",
+            __func__, len, m_cmdPos, m_flushPos, cmd->cmdSize);
+        abort();
+    }
+
+    if (len > VIRGL_MAX_CMDBUF_SIZE) {
+        ERR("%s: Large command (%zu bytes) exceeds virgl limits",
+            __func__, len);
+        /* Fall through */
+    }
+
+    memcpy(&m_buf[m_flushPos], buf, len);
+    commitBuffer(len);
+    m_allocSize += len;
+    return 0;
+}
+
+const unsigned char *VirtioGpuStream::readFully(void *buf, size_t len)
+{
+    if (!valid())
+        return nullptr;
+
+    if (!buf) {
+        if (len > 0) {
+            // If len is non-zero, buf must not be NULL. Otherwise the pipe would
+            // be in a corrupted state, which is lethal for the emulator.
+            ERR("%s: failed, buf=NULL, len %zu, lethal error, exiting.",
+                __func__, len);
+            abort();
+        }
+        return nullptr;
+    }
+
+    // Read is too big for current architecture
+    if (len > MAX_CMDRESPBUF_SIZE - sizeof(*m_cmdResp)) {
+        ERR("%s: failed, read too large, len %zu, lethal error, exiting.",
+            __func__, len);
+        abort();
+    }
+
+    // Commit all outstanding write commands (if any)
+    if (commitAll() < 0) {
+        ERR("%s: command flush failed", __func__);
+        return nullptr;
+    }
+
+    if (len > 0U && m_cmdRespPos == 0U) {
+        // When we are about to read for the first time, wait for the virtqueue
+        // to drain to this command, otherwise the data could be stale
+        drm_virtgpu_3d_wait wait = {
+            .handle = m_cmdResp_bo,
+        };
+        int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_WAIT, &wait);
+        if (ret) {
+            ERR("%s: failed with %d waiting for response buffer (%s)",
+                __func__, ret, strerror(errno));
+            // Fall through, hope for the best
+        }
+    }
+
+    // Most likely a protocol implementation error
+    if (m_cmdResp->cmdSize - sizeof(*m_cmdResp) < m_cmdRespPos + len) {
+        ERR("%s: failed, op %zu, len %zu, cmdSize %zu, pos %zu, lethal "
+            "error, exiting.", __func__, m_cmdResp->op, len,
+            m_cmdResp->cmdSize, m_cmdRespPos);
+        abort();
+    }
+
+    memcpy(buf, &m_cmdResp->buf[m_cmdRespPos], len);
+
+    if (m_cmdRespPos + len == m_cmdResp->cmdSize - sizeof(*m_cmdResp)) {
+        m_cmdRespPos = 0U;
+    } else {
+        m_cmdRespPos += len;
+    }
+
+    return reinterpret_cast<const unsigned char *>(buf);
+}
+
+int VirtioGpuStream::commitBuffer(size_t size)
+{
+    if (m_flushPos + size > m_bufSize) {
+        ERR("%s: illegal commit size %zu, flushPos %zu, bufSize %zu",
+            __func__, size, m_flushPos, m_bufSize);
+        return -1;
+    }
+    m_flushPos += size;
+    return 0;
+}
+
+int VirtioGpuStream::commitAll()
+{
+    size_t pos = 0U, numFlushed = 0U;
+    while (pos < m_flushPos) {
+        VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[pos]);
+
+        // Should never happen
+        if (pos + cmd->cmdSize > m_bufSize) {
+            ERR("%s: failed, pos %zu, cmdSize %zu, bufSize %zu, lethal "
+                "error, exiting.", __func__, pos, cmd->cmdSize, m_bufSize);
+            abort();
+        }
+
+        // Saw dummy command; patch it with res handle
+        if (cmd->op == 0) {
+            *(uint32_t *)cmd->buf = m_cmdResp_rh;
+        }
+
+        // Flush a single command
+        drm_virtgpu_execbuffer execbuffer = {
+            .size           = cmd->cmdSize,
+            .command        = reinterpret_cast<__u64>(cmd),
+            .bo_handles     = reinterpret_cast<__u64>(&m_cmdResp_bo),
+            .num_bo_handles = 1U,
+        };
+        int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_EXECBUFFER, &execbuffer);
+        if (ret) {
+            ERR("%s: failed with %d executing command buffer (%s)",  __func__,
+                ret, strerror(errno));
+            return -1;
+        }
+
+        pos += cmd->cmdSize;
+        numFlushed++;
+    }
+
+    if (pos > m_flushPos) {
+        ERR("%s: aliasing, flushPos %zu, pos %zu, probably ok", __func__,
+            m_flushPos, pos);
+        /* Fall through */
+    }
+
+    m_flushPos = 0U;
+    m_cmdPos = 0U;
+    return 0;
+}
diff --git a/system/OpenglSystemCommon/VirtioGpuStream.h b/system/OpenglSystemCommon/VirtioGpuStream.h
new file mode 100644
index 0000000..9d6faa5
--- /dev/null
+++ b/system/OpenglSystemCommon/VirtioGpuStream.h
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+#pragma once
+
+#include "HostConnection.h"
+#include "IOStream.h"
+
+#include <stdlib.h>
+
+/* This file implements an IOStream that uses VIRTGPU_EXECBUFFER ioctls on a
+ * virtio-gpu DRM rendernode device to communicate with the host.
+ */
+
+struct VirtioGpuCmd;
+
+class CrosGralloc : public Gralloc
+{
+    friend class VirtioGpuStream;
+
+public:
+    virtual uint32_t getHostHandle(native_handle_t const* handle);
+    virtual int getFormat(native_handle_t const* handle);
+
+private:
+    inline void setFd(int fd) { m_fd = fd; }
+    int m_fd = -1;
+};
+
+class VirtioGpuProcessPipe : public ProcessPipe
+{
+public:
+    virtual bool processPipeInit(renderControl_encoder_context_t *rcEnc);
+};
+
+class VirtioGpuStream : public IOStream
+{
+public:
+    explicit VirtioGpuStream(size_t bufSize);
+    ~VirtioGpuStream();
+
+    int connect();
+    Gralloc *getGralloc() { return &m_gralloc; }
+    ProcessPipe *getProcessPipe() { return &m_processPipe; }
+
+    // override IOStream so we can see non-rounded allocation sizes
+    virtual unsigned char *alloc(size_t len)
+    {
+        return static_cast<unsigned char *>(allocBuffer(len));
+    }
+
+    // override IOStream so we can model the caller's writes
+    virtual int flush();
+
+    virtual void *allocBuffer(size_t minSize);
+    virtual int writeFully(const void *buf, size_t len);
+    virtual const unsigned char *readFully(void *buf, size_t len);
+    virtual int commitBuffer(size_t size);
+    virtual const unsigned char *read(void *buf, size_t *inout_len) final
+    {
+        return readFully(buf, *inout_len);
+    }
+
+    bool valid()
+    {
+        return m_fd >= 0 && m_cmdResp_bo > 0 && m_cmdResp;
+    }
+
+private:
+    // rendernode fd
+    int m_fd;
+
+    // command memory buffer
+    size_t m_bufSize;
+    unsigned char *m_buf;
+
+    // response buffer res handle
+    uint32_t m_cmdResp_rh;
+
+    // response buffer ttm buffer object
+    uint32_t m_cmdResp_bo;
+
+    // user mapping of response buffer object
+    VirtioGpuCmd *m_cmdResp;
+
+    // byte offset to read cursor for last response
+    size_t m_cmdRespPos;
+
+    // byte offset to command being assembled
+    size_t m_cmdPos;
+
+    // byte offset to flush cursor
+    size_t m_flushPos;
+
+    // byte counter of allocs since last command boundary
+    size_t m_allocSize;
+
+    // bytes of an alloc flushed through flush() API
+    size_t m_allocFlushSize;
+
+    // CrOS gralloc interface
+    CrosGralloc m_gralloc;
+
+    // Fake process pipe implementation
+    VirtioGpuProcessPipe m_processPipe;
+
+    // commits all commands, resets buffer offsets
+    int commitAll();
+};
diff --git a/system/OpenglSystemCommon/goldfish_dma.h b/system/OpenglSystemCommon/goldfish_dma.h
deleted file mode 100644
index 6c1b09a..0000000
--- a/system/OpenglSystemCommon/goldfish_dma.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright (C) 2016 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- */
-
-#ifndef ANDROID_INCLUDE_HARDWARE_GOLDFISH_DMA_H
-#define ANDROID_INCLUDE_HARDWARE_GOLDFISH_DMA_H
-
-#include <errno.h>
-#include <linux/ioctl.h>
-#include <linux/types.h>
-#include <sys/cdefs.h>
-#include <fcntl.h>
-#include <stdlib.h>
-
-/* There is an ioctl associated with goldfish dma driver.
- * Make it conflict with ioctls that are not likely to be used
- * in the emulator.
- * 'G'	00-3F	drivers/misc/sgi-gru/grulib.h	conflict!
- * 'G'	00-0F	linux/gigaset_dev.h	conflict!
- */
-#define GOLDFISH_DMA_IOC_MAGIC	'G'
-
-#define GOLDFISH_DMA_IOC_LOCK			_IOWR(GOLDFISH_DMA_IOC_MAGIC, 0, struct goldfish_dma_ioctl_info)
-#define GOLDFISH_DMA_IOC_UNLOCK			_IOWR(GOLDFISH_DMA_IOC_MAGIC, 1, struct goldfish_dma_ioctl_info)
-#define GOLDFISH_DMA_IOC_GETOFF			_IOWR(GOLDFISH_DMA_IOC_MAGIC, 2, struct goldfish_dma_ioctl_info)
-#define GOLDFISH_DMA_IOC_CREATE_REGION	_IOWR(GOLDFISH_DMA_IOC_MAGIC, 3, struct goldfish_dma_ioctl_info)
-
-struct goldfish_dma_ioctl_info {
-    uint64_t phys_begin;
-    uint64_t size;
-};
-
-// userspace interface
-struct goldfish_dma_context {
-	uint64_t mapped_addr;
-	uint32_t size;
-	int32_t fd;
-};
-
-int goldfish_dma_lock(struct goldfish_dma_context* cxt);
-int goldfish_dma_unlock(struct goldfish_dma_context* cxt);
-int goldfish_dma_create_region(uint32_t sz, struct goldfish_dma_context* res);
-
-void* goldfish_dma_map(struct goldfish_dma_context* cxt);
-int goldfish_dma_unmap(struct goldfish_dma_context* cxt);
-
-void goldfish_dma_write(struct goldfish_dma_context* cxt,
-                        const void* to_write,
-                        uint32_t sz);
-
-void goldfish_dma_free(goldfish_dma_context* cxt);
-uint64_t goldfish_dma_guest_paddr(struct goldfish_dma_context* cxt);
-
-#endif
diff --git a/system/egl/Android.mk b/system/egl/Android.mk
index 9864e13..80778bd 100644
--- a/system/egl/Android.mk
+++ b/system/egl/Android.mk
@@ -13,27 +13,27 @@
     egl.cpp \
     ClientAPIExts.cpp
 
-ifdef IS_AT_LEAST_OPD1
-LOCAL_SHARED_LIBRARIES += libdl libnativewindow
-else
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
 LOCAL_SHARED_LIBRARIES += libdl
 endif
 
-ifdef IS_AT_LEAST_OPD1
-LOCAL_STATIC_LIBRARIES += libarect
-endif
-
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
 ifdef IS_AT_LEAST_OPM1
 LOCAL_HEADER_LIBRARIES += libui_headers
 endif
 
 ifdef IS_AT_LEAST_OPD1
 LOCAL_HEADER_LIBRARIES += libnativebase_headers
+LOCAL_STATIC_LIBRARIES += libarect
+LOCAL_SHARED_LIBRARIES += libnativewindow
 endif
 
 # Used to access the Bionic private OpenGL TLS slot
 LOCAL_C_INCLUDES += bionic/libc/private
 
+endif # !GOLDFISH_OPENGL_BUILD_FOR_HOST
+
 $(call emugl-end-module)
 
 #### egl.cfg ####
diff --git a/system/egl/CMakeLists.txt b/system/egl/CMakeLists.txt
new file mode 100644
index 0000000..56f92cd
--- /dev/null
+++ b/system/egl/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/egl/Android.mk" "4a6be27a2b501a86cad12c5876d0e766966574b11376ff8614fd92ffe94eb4b3")
+set(EGL_emulation_src eglDisplay.cpp egl.cpp ClientAPIExts.cpp)
+android_add_shared_library(EGL_emulation)
+target_include_directories(EGL_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(EGL_emulation PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"EGL_emulation\"" "-DEGL_EGLEXT_PROTOTYPES")
+target_compile_options(EGL_emulation PRIVATE "-fvisibility=default")
+target_link_libraries(EGL_emulation PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/egl/ClientAPIExts.cpp b/system/egl/ClientAPIExts.cpp
index 0f02dcb..40644e7 100644
--- a/system/egl/ClientAPIExts.cpp
+++ b/system/egl/ClientAPIExts.cpp
@@ -97,7 +97,8 @@
         if (!thread->currentContext) { \
             return; \
         } \
-        int idx = (int)thread->currentContext->majorVersion - 1; \
+        int clientMajorVersion = (int)thread->currentContext->majorVersion; \
+        int idx = clientMajorVersion == 1 ? 0 : 1; \
         if (!s_client_extensions[idx].fname) { \
             return; \
         } \
diff --git a/system/egl/ClientAPIExts.in b/system/egl/ClientAPIExts.in
index 5850701..a4595f2 100644
--- a/system/egl/ClientAPIExts.in
+++ b/system/egl/ClientAPIExts.in
@@ -199,3 +199,27 @@
 API_ENTRY(glDrawTexxvOES,
           (const GLfixed *coords),
           (coords))
+
+API_ENTRY(glBindVertexArrayOES,
+          (GLuint array),
+          (array))
+
+API_ENTRY(glDeleteVertexArraysOES,
+          (GLsizei n, const GLuint* arrays),
+          (n, arrays))
+
+API_ENTRY(glGenVertexArraysOES,
+          (GLsizei n, GLuint* arrays),
+          (n, arrays))
+
+API_ENTRY(glIsVertexArrayOES,
+          (GLuint array),
+          (array))
+
+API_ENTRY(glMapBufferOES,
+          (GLenum target, GLenum access),
+          (target, access))
+
+API_ENTRY(glUnmapBufferOES,
+          (GLenum target),
+          (target))
\ No newline at end of file
diff --git a/system/egl/egl.cpp b/system/egl/egl.cpp
index e52c5bd..23fb8cc 100644
--- a/system/egl/egl.cpp
+++ b/system/egl/egl.cpp
@@ -23,13 +23,13 @@
 #include <cutils/log.h>
 #include <cutils/properties.h>
 #include "goldfish_sync.h"
-#include "gralloc_cb.h"
 #include "GLClientState.h"
 #include "GLSharedGroup.h"
 #include "eglContext.h"
 #include "ClientAPIExts.h"
 #include "EGLImage.h"
 #include "ProcessPipe.h"
+#include "qemu_pipe.h"
 
 #include "GLEncoder.h"
 #ifdef WITH_GLES2
@@ -96,12 +96,12 @@
 
 #define setErrorReturn(error, retVal)     \
     {                                                \
-        ALOGE("tid %d: %s(%d): error 0x%x (%s)", gettid(), __FUNCTION__, __LINE__, error, eglStrError(error));     \
+        ALOGE("tid %d: %s(%d): error 0x%x (%s)", getCurrentThreadId(), __FUNCTION__, __LINE__, error, eglStrError(error));     \
         return setErrorFunc(error, retVal);            \
     }
 
 #define RETURN_ERROR(ret,err)           \
-    ALOGE("tid %d: %s(%d): error 0x%x (%s)", gettid(), __FUNCTION__, __LINE__, err, eglStrError(err));    \
+    ALOGE("tid %d: %s(%d): error 0x%x (%s)", getCurrentThreadId(), __FUNCTION__, __LINE__, err, eglStrError(err));    \
     getEGLThreadInfo()->eglError = err;    \
     return ret;
 
@@ -145,6 +145,11 @@
     if (!rcEnc) { \
         ALOGE("egl: Failed to get renderControl encoder context\n"); \
         return ret; \
+    } \
+    Gralloc *grallocHelper = hostCon->grallocHelper(); \
+    if (!grallocHelper) { \
+        ALOGE("egl: Failed to get grallocHelper\n"); \
+        return ret; \
     }
 
 #define DEFINE_AND_VALIDATE_HOST_CONNECTION_FOR_TLS(ret, tls) \
@@ -157,6 +162,11 @@
     if (!rcEnc) { \
         ALOGE("egl: Failed to get renderControl encoder context\n"); \
         return ret; \
+    } \
+    Gralloc const* grallocHelper = hostCon->grallocHelper(); \
+    if (!grallocHelper) { \
+        ALOGE("egl: Failed to get grallocHelper\n"); \
+        return ret; \
     }
 
 #define VALIDATE_CONTEXT_RETURN(context,ret)  \
@@ -396,12 +406,13 @@
     DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
     rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uintptr_t)config,
             getWidth(), getHeight());
+
     if (!rcSurface) {
         ALOGE("rcCreateWindowSurface returned 0");
         return EGL_FALSE;
     }
     rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface,
-            ((cb_handle_t*)(buffer->handle))->hostHandle);
+            grallocHelper->getHostHandle(buffer->handle));
 
     return EGL_TRUE;
 }
@@ -424,6 +435,7 @@
     if (rcSurface && rcEnc) {
         rcEnc->rcDestroyWindowSurface(rcEnc, rcSurface);
     }
+
     if (buffer) {
         nativeWindow->cancelBuffer_DEPRECATED(nativeWindow, buffer);
     }
@@ -468,6 +480,8 @@
                     thread_handle,
                     fd_out);
 
+        (void)queue_work_err;
+
         DPRINT("got native fence fd=%d queue_work_err=%d",
                *fd_out, queue_work_err);
     }
@@ -560,7 +574,7 @@
 #endif
 
     rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface,
-            ((cb_handle_t *)(buffer->handle))->hostHandle);
+            grallocHelper->getHostHandle(buffer->handle));
 
     setWidth(buffer->width);
     setHeight(buffer->height);
@@ -588,12 +602,13 @@
     EGLBoolean init(GLenum format);
 
     uint32_t rcColorBuffer;
+    QEMU_PIPE_HANDLE refcountPipeFd;
 };
 
 egl_pbuffer_surface_t::egl_pbuffer_surface_t(EGLDisplay dpy, EGLConfig config,
         EGLint surfType, int32_t w, int32_t h)
 :   egl_surface_t(dpy, config, surfType),
-    rcColorBuffer(0)
+    rcColorBuffer(0), refcountPipeFd(QEMU_PIPE_INVALID_HANDLE)
 {
     setWidth(w);
     setHeight(h);
@@ -603,7 +618,13 @@
 {
     DEFINE_HOST_CONNECTION;
     if (rcEnc) {
-        if (rcColorBuffer) rcEnc->rcCloseColorBuffer(rcEnc, rcColorBuffer);
+        if (rcColorBuffer){
+            if(qemu_pipe_valid(refcountPipeFd)) {
+                qemu_pipe_close(refcountPipeFd);
+            } else {
+                rcEnc->rcCloseColorBuffer(rcEnc, rcColorBuffer);
+            }
+        }
         if (rcSurface)     rcEnc->rcDestroyWindowSurface(rcEnc, rcSurface);
     }
 }
@@ -611,7 +632,10 @@
 // Destroy a pending surface and set it to NULL.
 
 static void s_destroyPendingSurfaceAndSetNull(EGLSurface* surface) {
-    if (!s_display.isSurface(surface)) {
+    if (!surface)
+        return;
+
+    if (!s_display.isSurface(*surface)) {
         *surface = NULL;
         return;
     }
@@ -651,6 +675,12 @@
     if (!rcColorBuffer) {
         ALOGE("rcCreateColorBuffer returned 0");
         return EGL_FALSE;
+    } else {
+        refcountPipeFd = qemu_pipe_open("refcount");
+        //Send color buffer handle in case RefCountPipe feature is turned on.
+        if (qemu_pipe_valid(refcountPipeFd)) {
+            qemu_pipe_write(refcountPipeFd, &rcColorBuffer, 4);
+        }
     }
 
     rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface, rcColorBuffer);
@@ -1274,7 +1304,10 @@
     tInfo->eglError = EGL_SUCCESS;
     EGLContext_t* context = tInfo->currentContext;
 
-    if (!context || !s_display.isContext(context)) return EGL_TRUE;
+    if (!context || !s_display.isContext(context)) {
+        HostConnection::exit();
+        return EGL_TRUE;
+    }
 
     // The following code is doing pretty much the same thing as
     // eglMakeCurrent(&s_display, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE)
@@ -1296,6 +1329,8 @@
     }
     tInfo->currentContext = 0;
 
+    HostConnection::exit();
+
     return EGL_TRUE;
 }
 
@@ -1948,9 +1983,9 @@
         if (native_buffer->common.version != sizeof(android_native_buffer_t))
             setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
 
-        cb_handle_t *cb = (cb_handle_t *)(native_buffer->handle);
-
-        switch (cb->format) {
+        DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
+        int format = grallocHelper->getFormat(native_buffer->handle);
+        switch (format) {
             case HAL_PIXEL_FORMAT_RGBA_8888:
             case HAL_PIXEL_FORMAT_RGBX_8888:
             case HAL_PIXEL_FORMAT_RGB_888:
diff --git a/system/egl/eglDisplay.cpp b/system/egl/eglDisplay.cpp
index f593598..70ee096 100644
--- a/system/egl/eglDisplay.cpp
+++ b/system/egl/eglDisplay.cpp
@@ -15,10 +15,17 @@
 */
 #include "eglDisplay.h"
 #include "HostConnection.h"
-#include <dlfcn.h>
+#include "KeyedVectorUtils.h"
+
+#ifdef HOST_BUILD
+#include "android/base/files/PathUtils.cpp"
+#include "android/base/system/System.cpp"
+#endif
 
 #include <string>
 
+#include <dlfcn.h>
+
 static const int systemEGLVersionMajor = 1;
 static const int systemEGLVersionMinor = 4;
 static const char systemEGLVendor[] = "Google Android emulator";
@@ -60,7 +67,7 @@
     m_hostRendererVersion(0),
     m_numConfigs(0),
     m_numConfigAttribs(0),
-    m_attribs(DefaultKeyedVector<EGLint, EGLint>(ATTRIBUTE_NONE)),
+    m_attribs(),
     m_configs(NULL),
     m_gles_iface(NULL),
     m_gles2_iface(NULL),
@@ -81,11 +88,7 @@
     pthread_mutex_destroy(&m_surfaceLock);
 }
 
-#if PLATFORM_SDK_VERSION >= 26
-#define PARTITION "/vendor"
-#else
-#define PARTITION "/system"
-#endif
+
 
 bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
 {
@@ -95,15 +98,9 @@
         //
         // load GLES client API
         //
-#if __LP64__
-        m_gles_iface = loadGLESClientAPI(PARTITION "/lib64/egl/libGLESv1_CM_emulation.so",
+        m_gles_iface = loadGLESClientAPI("libGLESv1_CM_emulation",
                                          eglIface,
                                          &s_gles_lib);
-#else
-        m_gles_iface = loadGLESClientAPI(PARTITION "/lib/egl/libGLESv1_CM_emulation.so",
-                                         eglIface,
-                                         &s_gles_lib);
-#endif
         if (!m_gles_iface) {
             pthread_mutex_unlock(&m_lock);
             ALOGE("Failed to load gles1 iface");
@@ -111,15 +108,9 @@
         }
 
 #ifdef WITH_GLES2
-#if __LP64__
-        m_gles2_iface = loadGLESClientAPI(PARTITION "/lib64/egl/libGLESv2_emulation.so",
+        m_gles2_iface = loadGLESClientAPI("libGLESv2_emulation",
                                           eglIface,
                                           &s_gles2_lib);
-#else
-        m_gles2_iface = loadGLESClientAPI(PARTITION "/lib/egl/libGLESv2_emulation.so",
-                                          eglIface,
-                                          &s_gles2_lib);
-#endif
         // Note that if loading gles2 failed, we can still run with no
         // GLES2 support, having GLES2 is not mandatory.
 #endif
@@ -186,21 +177,20 @@
             return false;
         }
 
-        //EGLint n = rcEnc->rcGetConfigs(rcEnc, nInts*sizeof(EGLint), m_configs);
         EGLint n = rcEnc->rcGetConfigs(rcEnc, nInts*sizeof(EGLint), (GLuint*)tmp_buf);
         if (n != m_numConfigs) {
             pthread_mutex_unlock(&m_lock);
             return false;
         }
 
-        //Fill the attributes vector.
-        //The first m_numConfigAttribs values of tmp_buf are the actual attributes enums.
+        // Fill the attributes vector.
+        // The first m_numConfigAttribs values of tmp_buf are the actual attributes enums.
         for (int i=0; i<m_numConfigAttribs; i++) {
-            m_attribs.add(tmp_buf[i], i);
+            m_attribs[tmp_buf[i]] = i;
         }
 
-        //Copy the actual configs data to m_configs
-        memcpy(m_configs, tmp_buf + m_numConfigAttribs, m_numConfigs*m_numConfigAttribs*sizeof(EGLint));
+        memcpy(m_configs, tmp_buf + m_numConfigAttribs,
+               m_numConfigs*m_numConfigAttribs*sizeof(EGLint));
 
         m_initialized = true;
     }
@@ -215,7 +205,6 @@
 {
     for (intptr_t i=0; i<m_numConfigs; i++) {
         EGLConfig config = (EGLConfig)i;
-        //Setup the EGL_NATIVE_VISUAL_ID attribute
         PixelFormat format;
         if (getConfigNativePixelFormat(config, &format)) {
             setConfigAttrib(config, EGL_NATIVE_VISUAL_ID, format);
@@ -261,13 +250,50 @@
     pthread_mutex_unlock(&m_lock);
 }
 
-EGLClient_glesInterface *eglDisplay::loadGLESClientAPI(const char *libName,
+#ifdef __APPLE__
+#define LIBSUFFIX ".dylib"
+#else
+#ifdef _WIN32
+#define LIBSUFFIX ".dll"
+#else
+#define LIBSUFFIX ".so"
+#endif // !_WIN32 (linux)
+#endif // !__APPLE__
+
+#ifndef HOST_BUILD
+#if PLATFORM_SDK_VERSION >= 26
+#define PARTITION "/vendor"
+#else
+#define PARTITION "/system"
+#endif // !PLATFORM_SDK_VERSION >= 26
+#if __LP64__
+#define LIBDIR "/lib64/egl/"
+#else
+#define LIBDIR "/lib/egl/"
+#endif // !__LP64__
+#endif // !HOST_BUILD
+
+EGLClient_glesInterface *eglDisplay::loadGLESClientAPI(const char *basename,
                                                        EGLClient_eglInterface *eglIface,
                                                        void **libHandle)
 {
-    void *lib = dlopen(libName, RTLD_NOW);
+#ifdef HOST_BUILD
+    std::string baseDir =
+        android::base::System::get()->getProgramDirectory();
+    std::string path =
+        android::base::pj(
+            baseDir, "lib64", std::string(basename) + LIBSUFFIX);
+    void *lib = dlopen(path.c_str(), RTLD_NOW);
+#else
+    std::string path(PARTITION);
+    path += LIBDIR;
+    path += basename;
+    path += LIBSUFFIX;
+    void *lib = dlopen(path.c_str(), RTLD_NOW);
+#endif
+
     if (!lib) {
-        ALOGE("Failed to dlopen %s", libName);
+        ALOGE("Failed to dlopen %s", basename);
         return NULL;
     }
 
@@ -462,7 +488,12 @@
     }
     //Though it seems that valueFor() is thread-safe, we don't take chanses
     pthread_mutex_lock(&m_lock);
-    EGLBoolean ret = getAttribValue(config, m_attribs.valueFor(attrib), value);
+    EGLBoolean ret =
+        getAttribValue(
+            config,
+            findObjectOrDefault(
+                m_attribs, attrib, EGL_DONT_CARE),
+            value);
     pthread_mutex_unlock(&m_lock);
     return ret;
 }
@@ -495,7 +526,14 @@
 {
     //Though it seems that valueFor() is thread-safe, we don't take chanses
     pthread_mutex_lock(&m_lock);
-    EGLBoolean ret = setAttribValue(config, m_attribs.valueFor(attrib), value);
+    EGLBoolean ret =
+        setAttribValue(
+            config,
+            findObjectOrDefault(
+                m_attribs,
+                attrib,
+                EGL_DONT_CARE),
+            value);
     pthread_mutex_unlock(&m_lock);
     return ret;
 }
@@ -505,11 +543,23 @@
 {
     EGLint redSize, blueSize, greenSize, alphaSize;
 
-    if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) )
-    {
+    if (!(
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_RED_SIZE, EGL_DONT_CARE),
+                &redSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_BLUE_SIZE, EGL_DONT_CARE),
+                &blueSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_GREEN_SIZE, EGL_DONT_CARE),
+                &greenSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_ALPHA_SIZE, EGL_DONT_CARE),
+                &alphaSize))) {
         ALOGE("Couldn't find value for one of the pixel format attributes");
         return EGL_FALSE;
     }
@@ -529,11 +579,23 @@
 {
     EGLint redSize, blueSize, greenSize, alphaSize;
 
-    if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) )
-    {
+    if (!(
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_RED_SIZE, EGL_DONT_CARE),
+                &redSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_BLUE_SIZE, EGL_DONT_CARE),
+                &blueSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_GREEN_SIZE, EGL_DONT_CARE),
+                &greenSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_ALPHA_SIZE, EGL_DONT_CARE),
+                &alphaSize))) {
         ALOGE("Couldn't find value for one of the pixel format attributes");
         return EGL_FALSE;
     }
diff --git a/system/egl/eglDisplay.h b/system/egl/eglDisplay.h
index 9fb6f07..2394da1 100644
--- a/system/egl/eglDisplay.h
+++ b/system/egl/eglDisplay.h
@@ -16,12 +16,12 @@
 #ifndef _SYSTEM_EGL_DISPLAY_H
 #define _SYSTEM_EGL_DISPLAY_H
 
+#include <assert.h>
 #include <pthread.h>
 #include "glUtils.h"
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 #include "EGLClientIface.h"
-#include <utils/KeyedVector.h>
 
 #if __cplusplus >= 201103L
 #include <unordered_set>
@@ -29,6 +29,7 @@
 #include <hash_set>
 #endif
 
+#include <map>
 
 #include <ui/PixelFormat.h>
 
@@ -88,7 +89,7 @@
     int  m_numConfigAttribs;
 
     /* This is the mapping between an attribute name to it's index in any given config */
-    DefaultKeyedVector<EGLint, EGLint>    m_attribs;
+    std::map<EGLint, EGLint>    m_attribs;
     /* This is an array of all config's attributes values stored in the following sequencial fasion (read: v[c,a] = the value of attribute <a> of config <c>)
      * v[0,0],..,v[0,m_numConfigAttribs-1],
      *...
diff --git a/system/egl/goldfish_sync.h b/system/egl/goldfish_sync.h
index 5dcc449..ec29bee 100644
--- a/system/egl/goldfish_sync.h
+++ b/system/egl/goldfish_sync.h
@@ -15,6 +15,26 @@
 #ifndef ANDROID_INCLUDE_HARDWARE_GOLDFISH_SYNC_H
 #define ANDROID_INCLUDE_HARDWARE_GOLDFISH_SYNC_H
 
+#ifdef HOST_BUILD
+
+static __inline__ int goldfish_sync_open() {
+    return 0;
+}
+
+static __inline__ int goldfish_sync_close(int sync_fd) {
+    return 0;
+}
+
+static __inline__ int goldfish_sync_queue_work(int goldfish_sync_fd,
+                                                uint64_t host_glsync,
+                                                uint64_t host_thread,
+                                                int* fd_out) {
+    return 0;
+}
+
+#else
+
+#include <errno.h>
 #include <linux/ioctl.h>
 #include <linux/types.h>
 #include <sys/cdefs.h>
@@ -79,4 +99,6 @@
     return err;
 }
 
+#endif // !HOST_BUILD
+
 #endif
diff --git a/system/enc_common/IOStream_common.cpp b/system/enc_common/IOStream_common.cpp
index 43f03af..901ad1d 100644
--- a/system/enc_common/IOStream_common.cpp
+++ b/system/enc_common/IOStream_common.cpp
@@ -6,6 +6,8 @@
 
 #include <vector>
 
+#include <assert.h>
+
 void IOStream::readbackPixels(void* context, int width, int height, unsigned int format, unsigned int type, void* pixels) {
     GL2Encoder *ctx = (GL2Encoder *)context;
     assert (ctx->state() != NULL);
diff --git a/system/gralloc/Android.mk b/system/gralloc/Android.mk
index 190bfd6..88dd193 100644
--- a/system/gralloc/Android.mk
+++ b/system/gralloc/Android.mk
@@ -12,9 +12,11 @@
 
 LOCAL_SRC_FILES := gralloc.cpp
 
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
 # Need to access the special OPENGL TLS Slot
 LOCAL_C_INCLUDES += bionic/libc/private
 LOCAL_SHARED_LIBRARIES += libdl
+endif
 
 $$(call emugl-end-module)
 endef  # define gralloc_recipe
diff --git a/system/gralloc/CMakeLists.txt b/system/gralloc/CMakeLists.txt
new file mode 100644
index 0000000..22318ae
--- /dev/null
+++ b/system/gralloc/CMakeLists.txt
@@ -0,0 +1,20 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/gralloc/Android.mk" "3898852aade0f86cf9db2d73e90a5294e04aebb513e4757bf5f9ceaaeab528bb")
+set(gralloc.goldfish_src gralloc.cpp)
+android_add_shared_library(gralloc.goldfish)
+target_include_directories(gralloc.goldfish PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(gralloc.goldfish PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"gralloc_goldfish\"")
+target_compile_options(gralloc.goldfish PRIVATE "-fvisibility=default" "-Wno-missing-field-initializers")
+target_link_libraries(gralloc.goldfish PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log GLESv2_enc _renderControl_enc GLESv1_enc OpenglCodecCommon_host)
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/gralloc/Android.mk" "3898852aade0f86cf9db2d73e90a5294e04aebb513e4757bf5f9ceaaeab528bb")
+set(gralloc.ranchu_src gralloc.cpp)
+android_add_shared_library(gralloc.ranchu)
+target_include_directories(gralloc.ranchu PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(gralloc.ranchu PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"gralloc_ranchu\"")
+target_compile_options(gralloc.ranchu PRIVATE "-fvisibility=default" "-Wno-missing-field-initializers")
+target_link_libraries(gralloc.ranchu PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log GLESv2_enc _renderControl_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/gralloc/gralloc.cpp b/system/gralloc/gralloc.cpp
index fc68f4e..48b4079 100644
--- a/system/gralloc/gralloc.cpp
+++ b/system/gralloc/gralloc.cpp
@@ -21,13 +21,21 @@
 #include <errno.h>
 #include <dlfcn.h>
 #include <sys/mman.h>
+
+#if PLATFORM_SDK_VERSION < 28
 #include "gralloc_cb.h"
+#else
+#include "../../shared/OpenglCodecCommon/gralloc_cb.h"
+#endif
+
 #include "goldfish_dma.h"
 #include "FormatConversions.h"
 #include "HostConnection.h"
 #include "ProcessPipe.h"
+#include "ThreadInfo.h"
 #include "glUtils.h"
-#include <utils/CallStack.h>
+#include "qemu_pipe.h"
+
 #include <cutils/log.h>
 #include <cutils/properties.h>
 
@@ -339,6 +347,13 @@
         return -EIO; \
     }
 
+#define EXIT_GRALLOCONLY_HOST_CONNECTION \
+    if (hostCon && hostCon->isGrallocOnly()) { \
+        ALOGD("%s: exiting HostConnection (is buffer-handling thread)", \
+              __FUNCTION__); \
+        HostConnection::exit(); \
+    }
+
 #if PLATFORM_SDK_VERSION < 18
 // On older APIs, just define it as a value no one is going to use.
 #define HAL_PIXEL_FORMAT_YCbCr_420_888 0xFFFFFFFF
@@ -665,7 +680,7 @@
     }
 
     D("gralloc_alloc format=%d, ashmem_size=%d, stride=%d, tid %d\n", format,
-            ashmem_size, stride, gettid());
+      ashmem_size, stride, getCurrentThreadId());
 
     //
     // Allocate space in ashmem if needed
@@ -731,7 +746,6 @@
             } else {
                 cb->hostHandle = rcEnc->rcCreateColorBuffer(rcEnc, w, h, allocFormat);
             }
-            D("Created host ColorBuffer 0x%x\n", cb->hostHandle);
         }
 
         if (!cb->hostHandle) {
@@ -740,6 +754,13 @@
             delete cb;
             ALOGD("%s: failed to create host cb! -EIO", __FUNCTION__);
             return -EIO;
+        } else {
+            QEMU_PIPE_HANDLE refcountPipeFd = qemu_pipe_open("refcount");
+            if(qemu_pipe_valid(refcountPipeFd)) {
+                cb->setRefcountPipeFd(refcountPipeFd);
+                qemu_pipe_write(refcountPipeFd, &cb->hostHandle, 4);
+            }
+            D("Created host ColorBuffer 0x%x\n", cb->hostHandle);
         }
 
         if (isHidlGralloc) { *getOpenCountPtr(cb) = 0; }
@@ -785,11 +806,13 @@
     D("%s: for buf %p ptr %p size %d\n",
       __FUNCTION__, handle, cb->ashmemBase, cb->ashmemSize);
 
-    if (cb->hostHandle) {
+    if (cb->hostHandle && !cb->hasRefcountPipe()) {
         int32_t openCount = 1;
         int32_t* openCountPtr = &openCount;
 
-        if (isHidlGralloc) { openCountPtr = getOpenCountPtr(cb); }
+        if (isHidlGralloc && cb->ashmemBase) {
+            openCountPtr = getOpenCountPtr(cb);
+        }
 
         if (*openCountPtr > 0) {
             DEFINE_AND_VALIDATE_HOST_CONNECTION;
@@ -813,6 +836,9 @@
         close(cb->fd);
     }
 
+    if(qemu_pipe_valid(cb->refcount_pipe_fd)) {
+        qemu_pipe_close(cb->refcount_pipe_fd);
+    }
     D("%s: done", __FUNCTION__);
     // remove it from the allocated list
     gralloc_device_t *grdev = (gralloc_device_t *)dev;
@@ -943,7 +969,7 @@
 {
     fb_device_t *fbdev = (fb_device_t *)dev;
 
-    delete fbdev;
+    free(fbdev);
 
     return 0;
 }
@@ -973,7 +999,7 @@
     D("gralloc_register_buffer(%p) w %d h %d format 0x%x framworkFormat 0x%x",
         handle, cb->width, cb->height, cb->format, cb->frameworkFormat);
 
-    if (cb->hostHandle != 0) {
+    if (cb->hostHandle != 0 && !cb->hasRefcountPipe()) {
         DEFINE_AND_VALIDATE_HOST_CONNECTION;
         D("Opening host ColorBuffer 0x%x\n", cb->hostHandle);
         rcEnc->rcOpenColorBuffer2(rcEnc, cb->hostHandle);
@@ -1029,7 +1055,7 @@
     }
 
 
-    if (cb->hostHandle) {
+    if (cb->hostHandle && !cb->hasRefcountPipe()) {
         D("Closing host ColorBuffer 0x%x\n", cb->hostHandle);
         DEFINE_AND_VALIDATE_HOST_CONNECTION;
         rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle);
@@ -1046,6 +1072,8 @@
                 }
             }
         }
+        EXIT_GRALLOCONLY_HOST_CONNECTION;
+
     }
 
     //
@@ -1070,6 +1098,7 @@
         cb->ashmemBase = 0;
         cb->mappedPid = 0;
         D("%s: Unregister buffer previous mapped to pid %d", __FUNCTION__, getpid());
+        EXIT_GRALLOCONLY_HOST_CONNECTION;
     }
 
 done:
@@ -1173,7 +1202,7 @@
             // host failed the color buffer sync - probably since it was already
             // locked for write access. fail the lock.
             ALOGE("gralloc_lock cacheFlush failed postCount=%d sw_read=%d\n",
-                 postCount, sw_read);
+                 (int)postCount, sw_read);
             return -EBUSY;
         }
 
diff --git a/system/hwc2/Android.mk b/system/hwc2/Android.mk
new file mode 100644
index 0000000..a3bf20f
--- /dev/null
+++ b/system/hwc2/Android.mk
@@ -0,0 +1,61 @@
+#
+# 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_VENDOR_MODULE := true
+emulator_hwcomposer_shared_libraries := \
+    liblog \
+    libutils \
+    libcutils \
+    libEGL \
+    libutils \
+    libhardware \
+    libsync \
+    libui \
+
+emulator_hwcomposer_cflags += \
+    -DLOG_TAG=\"hwc2\"
+
+emulator_hwcomposer_c_includes += \
+    system/core/libsync \
+    system/core/libsync/include \
+    device/generic/goldfish-opengl/system/include \
+    device/generic/goldfish-opengl/system/OpenglSystemCommon \
+    device/generic/goldfish-opengl/host/include/libOpenglRender \
+    device/generic/goldfish-opengl/shared/OpenglCodecCommon \
+    device/generic/goldfish-opengl/system/renderControl_enc
+
+emulator_hwcomposer_relative_path := hw
+
+emulator_hwcomposer2_src_files := \
+    EmuHWC2.cpp \
+    MiniFence.cpp
+
+include $(CLEAR_VARS)
+
+LOCAL_VENDOR_MODULE := true
+LOCAL_SHARED_LIBRARIES := $(emulator_hwcomposer_shared_libraries)
+LOCAL_SHARED_LIBRARIES += libOpenglSystemCommon lib_renderControl_enc
+LOCAL_SRC_FILES := $(emulator_hwcomposer2_src_files)
+LOCAL_C_INCLUDES := $(emulator_hwcomposer_c_includes)
+LOCAL_MODULE_RELATIVE_PATH := $(emulator_hwcomposer_relative_path)
+
+LOCAL_MODULE := hwcomposer.ranchu
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/system/hwc2/EmuHWC2.cpp b/system/hwc2/EmuHWC2.cpp
new file mode 100644
index 0000000..37466a1
--- /dev/null
+++ b/system/hwc2/EmuHWC2.cpp
@@ -0,0 +1,1336 @@
+/*
+ * Copyright 2018 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 "EmuHWC2.h"
+#define LOG_NDEBUG 0
+//#define LOG_NNDEBUG 0
+#undef LOG_TAG
+#define LOG_TAG "EmuHWC2"
+
+#include <errno.h>
+#include <log/log.h>
+#include <sync/sync.h>
+
+#if defined(LOG_NNDEBUG) && LOG_NNDEBUG == 0
+#define ALOGVV ALOGV
+#else
+#define ALOGVV(...) ((void)0)
+#endif
+
+template <typename PFN, typename T>
+static hwc2_function_pointer_t asFP(T function)
+{
+    static_assert(std::is_same<PFN, T>::value, "Incompatible function pointer");
+    return reinterpret_cast<hwc2_function_pointer_t>(function);
+}
+
+#define DEFINE_AND_VALIDATE_HOST_CONNECTION \
+    HostConnection *hostCon = HostConnection::get(); \
+    if (!hostCon) { \
+        ALOGE("EmuHWC2: Failed to get host connection\n"); \
+        return Error::NoResources; \
+    } \
+    ExtendedRCEncoderContext *rcEnc = hostCon->rcEncoder(); \
+    if (!rcEnc) { \
+        ALOGE("EmuHWC2: Failed to get renderControl encoder context\n"); \
+        return Error::NoResources; \
+    }
+
+
+using namespace HWC2;
+
+namespace android {
+
+EmuHWC2::EmuHWC2()
+  : mStateMutex()
+{
+    common.tag = HARDWARE_DEVICE_TAG;
+    common.version = HWC_DEVICE_API_VERSION_2_0;
+    common.close = closeHook;
+    getCapabilities = getCapabilitiesHook;
+    getFunction = getFunctionHook;
+    populateCapabilities();
+}
+
+void EmuHWC2::doGetCapabilities(uint32_t* outCount, int32_t* outCapabilities) {
+    if (outCapabilities == nullptr) {
+        *outCount = mCapabilities.size();
+        return;
+    }
+
+    auto capabilityIter = mCapabilities.cbegin();
+    for (size_t i = 0; i < *outCount; ++i) {
+        if (capabilityIter == mCapabilities.cend()) {
+            return;
+        }
+        outCapabilities[i] = static_cast<int32_t>(*capabilityIter);
+        ++capabilityIter;
+    }
+}
+
+hwc2_function_pointer_t EmuHWC2::doGetFunction(
+        FunctionDescriptor descriptor) {
+    switch(descriptor) {
+        case FunctionDescriptor::CreateVirtualDisplay:
+            return asFP<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>(
+                    createVirtualDisplayHook);
+        case FunctionDescriptor::DestroyVirtualDisplay:
+            return asFP<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(
+                    destroyVirtualDisplayHook);
+        case FunctionDescriptor::Dump:
+            return asFP<HWC2_PFN_DUMP>(dumpHook);
+        case FunctionDescriptor::GetMaxVirtualDisplayCount:
+            return asFP<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>(
+                    getMaxVirtualDisplayCountHook);
+        case FunctionDescriptor::RegisterCallback:
+            return asFP<HWC2_PFN_REGISTER_CALLBACK>(registerCallbackHook);
+
+            // Display functions
+        case FunctionDescriptor::AcceptDisplayChanges:
+            return asFP<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>(
+                    displayHook<decltype(&Display::acceptChanges),
+                    &Display::acceptChanges>);
+        case FunctionDescriptor::CreateLayer:
+            return asFP<HWC2_PFN_CREATE_LAYER>(
+                    displayHook<decltype(&Display::createLayer),
+                    &Display::createLayer, hwc2_layer_t*>);
+        case FunctionDescriptor::DestroyLayer:
+            return asFP<HWC2_PFN_DESTROY_LAYER>(
+                    displayHook<decltype(&Display::destroyLayer),
+                    &Display::destroyLayer, hwc2_layer_t>);
+        case FunctionDescriptor::GetActiveConfig:
+            return asFP<HWC2_PFN_GET_ACTIVE_CONFIG>(
+                    displayHook<decltype(&Display::getActiveConfig),
+                    &Display::getActiveConfig, hwc2_config_t*>);
+        case FunctionDescriptor::GetChangedCompositionTypes:
+            return asFP<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(
+                    displayHook<decltype(&Display::getChangedCompositionTypes),
+                    &Display::getChangedCompositionTypes, uint32_t*,
+                    hwc2_layer_t*, int32_t*>);
+        case FunctionDescriptor::GetColorModes:
+            return asFP<HWC2_PFN_GET_COLOR_MODES>(
+                    displayHook<decltype(&Display::getColorModes),
+                    &Display::getColorModes, uint32_t*, int32_t*>);
+        case FunctionDescriptor::GetDisplayAttribute:
+            return asFP<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(
+                    displayHook<decltype(&Display::getDisplayAttribute),
+                    &Display::getDisplayAttribute, hwc2_config_t,
+                    int32_t, int32_t*>);
+        case FunctionDescriptor::GetDisplayConfigs:
+            return asFP<HWC2_PFN_GET_DISPLAY_CONFIGS>(
+                    displayHook<decltype(&Display::getConfigs),
+                    &Display::getConfigs, uint32_t*, hwc2_config_t*>);
+        case FunctionDescriptor::GetDisplayName:
+            return asFP<HWC2_PFN_GET_DISPLAY_NAME>(
+                    displayHook<decltype(&Display::getName),
+                    &Display::getName, uint32_t*, char*>);
+        case FunctionDescriptor::GetDisplayRequests:
+            return asFP<HWC2_PFN_GET_DISPLAY_REQUESTS>(
+                    displayHook<decltype(&Display::getRequests),
+                    &Display::getRequests, int32_t*, uint32_t*, hwc2_layer_t*,
+                    int32_t*>);
+        case FunctionDescriptor::GetDisplayType:
+            return asFP<HWC2_PFN_GET_DISPLAY_TYPE>(
+                    displayHook<decltype(&Display::getType),
+                    &Display::getType, int32_t*>);
+        case FunctionDescriptor::GetDozeSupport:
+            return asFP<HWC2_PFN_GET_DOZE_SUPPORT>(
+                    displayHook<decltype(&Display::getDozeSupport),
+                    &Display::getDozeSupport, int32_t*>);
+        case FunctionDescriptor::GetHdrCapabilities:
+            return asFP<HWC2_PFN_GET_HDR_CAPABILITIES>(
+                    displayHook<decltype(&Display::getHdrCapabilities),
+                    &Display::getHdrCapabilities, uint32_t*, int32_t*, float*,
+                    float*, float*>);
+        case FunctionDescriptor::GetReleaseFences:
+            return asFP<HWC2_PFN_GET_RELEASE_FENCES>(
+                    displayHook<decltype(&Display::getReleaseFences),
+                    &Display::getReleaseFences, uint32_t*, hwc2_layer_t*,
+                    int32_t*>);
+        case FunctionDescriptor::PresentDisplay:
+            return asFP<HWC2_PFN_PRESENT_DISPLAY>(
+                    displayHook<decltype(&Display::present),
+                    &Display::present, int32_t*>);
+        case FunctionDescriptor::SetActiveConfig:
+            return asFP<HWC2_PFN_SET_ACTIVE_CONFIG>(
+                    displayHook<decltype(&Display::setActiveConfig),
+                    &Display::setActiveConfig, hwc2_config_t>);
+        case FunctionDescriptor::SetClientTarget:
+            return asFP<HWC2_PFN_SET_CLIENT_TARGET>(
+                    displayHook<decltype(&Display::setClientTarget),
+                    &Display::setClientTarget, buffer_handle_t, int32_t,
+                    int32_t, hwc_region_t>);
+        case FunctionDescriptor::SetColorMode:
+            return asFP<HWC2_PFN_SET_COLOR_MODE>(
+                    displayHook<decltype(&Display::setColorMode),
+                    &Display::setColorMode, int32_t>);
+        case FunctionDescriptor::SetColorTransform:
+            return asFP<HWC2_PFN_SET_COLOR_TRANSFORM>(
+                    displayHook<decltype(&Display::setColorTransform),
+                    &Display::setColorTransform, const float*, int32_t>);
+        case FunctionDescriptor::SetOutputBuffer:
+            return asFP<HWC2_PFN_SET_OUTPUT_BUFFER>(
+                    displayHook<decltype(&Display::setOutputBuffer),
+                    &Display::setOutputBuffer, buffer_handle_t, int32_t>);
+        case FunctionDescriptor::SetPowerMode:
+            return asFP<HWC2_PFN_SET_POWER_MODE>(
+                    displayHook<decltype(&Display::setPowerMode),
+                    &Display::setPowerMode, int32_t>);
+        case FunctionDescriptor::SetVsyncEnabled:
+            return asFP<HWC2_PFN_SET_VSYNC_ENABLED>(
+                    displayHook<decltype(&Display::setVsyncEnabled),
+                    &Display::setVsyncEnabled, int32_t>);
+        case FunctionDescriptor::ValidateDisplay:
+            return asFP<HWC2_PFN_VALIDATE_DISPLAY>(
+                    displayHook<decltype(&Display::validate),
+                    &Display::validate, uint32_t*, uint32_t*>);
+        case FunctionDescriptor::GetClientTargetSupport:
+            return asFP<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(
+                    displayHook<decltype(&Display::getClientTargetSupport),
+                    &Display::getClientTargetSupport, uint32_t, uint32_t,
+                                                      int32_t, int32_t>);
+        // Layer functions
+        case FunctionDescriptor::SetCursorPosition:
+            return asFP<HWC2_PFN_SET_CURSOR_POSITION>(
+                    layerHook<decltype(&Layer::setCursorPosition),
+                    &Layer::setCursorPosition, int32_t, int32_t>);
+        case FunctionDescriptor::SetLayerBuffer:
+            return asFP<HWC2_PFN_SET_LAYER_BUFFER>(
+                    layerHook<decltype(&Layer::setBuffer), &Layer::setBuffer,
+                    buffer_handle_t, int32_t>);
+        case FunctionDescriptor::SetLayerSurfaceDamage:
+            return asFP<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>(
+                    layerHook<decltype(&Layer::setSurfaceDamage),
+                    &Layer::setSurfaceDamage, hwc_region_t>);
+
+        // Layer state functions
+        case FunctionDescriptor::SetLayerBlendMode:
+            return asFP<HWC2_PFN_SET_LAYER_BLEND_MODE>(
+                    layerHook<decltype(&Layer::setBlendMode),
+                    &Layer::setBlendMode, int32_t>);
+        case FunctionDescriptor::SetLayerColor:
+            return asFP<HWC2_PFN_SET_LAYER_COLOR>(
+                    layerHook<decltype(&Layer::setColor), &Layer::setColor,
+                    hwc_color_t>);
+        case FunctionDescriptor::SetLayerCompositionType:
+            return asFP<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(
+                    layerHook<decltype(&Layer::setCompositionType),
+                    &Layer::setCompositionType, int32_t>);
+        case FunctionDescriptor::SetLayerDataspace:
+            return asFP<HWC2_PFN_SET_LAYER_DATASPACE>(
+                    layerHook<decltype(&Layer::setDataspace),
+                    &Layer::setDataspace, int32_t>);
+        case FunctionDescriptor::SetLayerDisplayFrame:
+            return asFP<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(
+                    layerHook<decltype(&Layer::setDisplayFrame),
+                    &Layer::setDisplayFrame, hwc_rect_t>);
+        case FunctionDescriptor::SetLayerPlaneAlpha:
+            return asFP<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(
+                    layerHook<decltype(&Layer::setPlaneAlpha),
+                    &Layer::setPlaneAlpha, float>);
+        case FunctionDescriptor::SetLayerSidebandStream:
+            return asFP<HWC2_PFN_SET_LAYER_SIDEBAND_STREAM>(
+                    layerHook<decltype(&Layer::setSidebandStream),
+                    &Layer::setSidebandStream, const native_handle_t*>);
+        case FunctionDescriptor::SetLayerSourceCrop:
+            return asFP<HWC2_PFN_SET_LAYER_SOURCE_CROP>(
+                    layerHook<decltype(&Layer::setSourceCrop),
+                    &Layer::setSourceCrop, hwc_frect_t>);
+        case FunctionDescriptor::SetLayerTransform:
+            return asFP<HWC2_PFN_SET_LAYER_TRANSFORM>(
+                    layerHook<decltype(&Layer::setTransform),
+                    &Layer::setTransform, int32_t>);
+        case FunctionDescriptor::SetLayerVisibleRegion:
+            return asFP<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(
+                    layerHook<decltype(&Layer::setVisibleRegion),
+                    &Layer::setVisibleRegion, hwc_region_t>);
+        case FunctionDescriptor::SetLayerZOrder:
+            return asFP<HWC2_PFN_SET_LAYER_Z_ORDER>(
+                    displayHook<decltype(&Display::updateLayerZ),
+                    &Display::updateLayerZ, hwc2_layer_t, uint32_t>);
+
+        default:
+            ALOGE("doGetFunction: Unknown function descriptor: %d (%s)",
+                    static_cast<int32_t>(descriptor),
+                    to_string(descriptor).c_str());
+            return nullptr;
+    }
+}
+
+
+// Device functions
+
+Error EmuHWC2::createVirtualDisplay(uint32_t /*width*/, uint32_t /*height*/,
+        int32_t* /*format*/, hwc2_display_t* /*outDisplay*/) {
+    ALOGVV("%s", __FUNCTION__);
+    //TODO: VirtualDisplay support
+    return Error::None;
+}
+
+Error EmuHWC2::destroyVirtualDisplay(hwc2_display_t /*displayId*/) {
+    ALOGVV("%s", __FUNCTION__);
+    //TODO: VirtualDisplay support
+    return Error::None;
+}
+
+void EmuHWC2::dump(uint32_t* /*outSize*/, char* /*outBuffer*/) {
+    ALOGVV("%s", __FUNCTION__);
+    //TODO:
+    return;
+}
+
+uint32_t EmuHWC2::getMaxVirtualDisplayCount() {
+    ALOGVV("%s", __FUNCTION__);
+    //TODO: VirtualDisplay support
+    return 0;
+}
+
+static bool isValid(Callback descriptor) {
+    switch (descriptor) {
+        case Callback::Hotplug: // Fall-through
+        case Callback::Refresh: // Fall-through
+        case Callback::Vsync: return true;
+        default: return false;
+    }
+}
+
+Error EmuHWC2::registerCallback(Callback descriptor,
+        hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer) {
+    ALOGVV("%s", __FUNCTION__);
+    if (!isValid(descriptor)) {
+        ALOGE("registerCallback: Unkown function descriptor: %d",
+                static_cast<int32_t>(descriptor));
+        return Error::BadParameter;
+    }
+    ALOGV("registerCallback(%s, %p, %p)", to_string(descriptor).c_str(),
+            callbackData, pointer);
+
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (pointer != nullptr) {
+        mCallbacks[descriptor] = {callbackData, pointer};
+    }
+    else {
+        ALOGV("unregisterCallback(%s)", to_string(descriptor).c_str());
+        mCallbacks.erase(descriptor);
+        return Error::None;
+    }
+
+    // Callback without the state lock held
+    if (descriptor == Callback::Hotplug) {
+        lock.unlock();
+        auto hotplug = reinterpret_cast<HWC2_PFN_VSYNC>(pointer);
+        hotplug(callbackData, 0, static_cast<int32_t>(Connection::Connected));
+    }
+
+    return Error::None;
+}
+
+//Gralloc Functions
+EmuHWC2::GrallocModule::GrallocModule() {
+    int ret;
+
+    ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &mHw);
+    assert(ret == 0 && "Gralloc moudle not found");
+    mGralloc = reinterpret_cast<const gralloc_module_t*>(mHw);
+
+    ret = framebuffer_open(mHw, &mFbDev);
+    assert(ret == 0 && "Fail to open FrameBuffer device");
+}
+
+EmuHWC2::GrallocModule::~GrallocModule() {
+    if (mHandle != nullptr) {
+        mGralloc->unregisterBuffer(mGralloc, mHandle);
+        mAllocDev->free(mAllocDev, mHandle);
+        ALOGI("free targetCb %d", ((cb_handle_t*)(mHandle))->hostHandle);
+    }
+}
+
+uint32_t EmuHWC2::GrallocModule::getTargetCb() {
+    if (mHandle == nullptr) {
+        int ret, stride;
+        ret = gralloc_open(mHw, &mAllocDev);
+        assert(ret == 0 && "Fail to open GPU device");
+        ret = mAllocDev->alloc(mAllocDev,
+                               mFbDev->width, mFbDev->height, mFbDev->format,
+                               GRALLOC_USAGE_HW_COMPOSER|GRALLOC_USAGE_HW_RENDER,
+                               &mHandle, &stride);
+        assert(ret == 0 && "Fail to allocate target ColorBuffer");
+        mGralloc->registerBuffer(mGralloc, mHandle);
+        ALOGI("targetCb %d", reinterpret_cast<const cb_handle_t*>(mHandle)
+              ->hostHandle);
+    }
+    return reinterpret_cast<const cb_handle_t*>(mHandle)->hostHandle;
+}
+
+// Display functions
+
+std::atomic<hwc2_display_t> EmuHWC2::Display::sNextId(0);
+
+EmuHWC2::Display::Display(EmuHWC2& device, DisplayType type)
+  : mDevice(device),
+    mId(sNextId++),
+    mName(),
+    mType(type),
+    mPowerMode(PowerMode::Off),
+    mVsyncEnabled(Vsync::Invalid),
+    mVsyncPeriod(1000*1000*1000/60), // vsync is 60 hz
+    mVsyncThread(*this),
+    mClientTarget(),
+    mChanges(),
+    mLayers(),
+    mConfigs(),
+    mActiveConfig(nullptr),
+    mColorModes(),
+    mSetColorTransform(false),
+    mStateMutex()
+    {
+        mVsyncThread.run("", HAL_PRIORITY_URGENT_DISPLAY);
+    }
+
+Error EmuHWC2::Display::acceptChanges() {
+    ALOGVV("%s: displayId %u", __FUNCTION__, (uint32_t)mId);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (!mChanges) {
+        ALOGW("%s: displayId %u acceptChanges failed, not validated",
+              __FUNCTION__, (uint32_t)mId);
+        return Error::NotValidated;
+    }
+
+
+    for (auto& change : mChanges->getTypeChanges()) {
+        auto layerId = change.first;
+        auto type = change.second;
+        if (mDevice.mLayers.count(layerId) == 0) {
+            // This should never happen but somehow does.
+            ALOGW("Cannot accept change for unknown layer %u",
+                  (uint32_t)layerId);
+            continue;
+        }
+        auto layer = mDevice.mLayers[layerId];
+        layer->setCompositionType((int32_t)type);
+    }
+
+    mChanges->clearTypeChanges();
+    return Error::None;
+}
+
+Error EmuHWC2::Display::createLayer(hwc2_layer_t* outLayerId) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    auto layer = *mLayers.emplace(std::make_shared<Layer>(*this));
+    mDevice.mLayers.emplace(std::make_pair(layer->getId(), layer));
+    *outLayerId = layer->getId();
+    ALOGV("%s: Display %u created layer %u", __FUNCTION__, (uint32_t)mId,
+         (uint32_t)(*outLayerId));
+    return Error::None;
+}
+
+Error EmuHWC2::Display::destroyLayer(hwc2_layer_t layerId) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    const auto mapLayer = mDevice.mLayers.find(layerId);
+    if (mapLayer == mDevice.mLayers.end()) {
+        ALOGW("%s failed: no such layer, displayId %u layerId %u",
+             __FUNCTION__, (uint32_t)mId, (uint32_t)layerId);
+        return Error::BadLayer;
+    }
+    const auto layer = mapLayer->second;
+    mDevice.mLayers.erase(mapLayer);
+    const auto zRange = mLayers.equal_range(layer);
+    for (auto current = zRange.first; current != zRange.second; ++current) {
+        if (**current == *layer) {
+            current = mLayers.erase(current);
+            break;
+        }
+    }
+    ALOGV("%s: displayId %d layerId %d", __FUNCTION__, (uint32_t)mId,
+         (uint32_t)layerId);
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getActiveConfig(hwc2_config_t* outConfig) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (!mActiveConfig) {
+        ALOGW("%s: displayId %d %s", __FUNCTION__, (uint32_t)mId,
+                to_string(Error::BadConfig).c_str());
+        return Error::BadConfig;
+    }
+    auto configId = mActiveConfig->getId();
+    ALOGV("%s: displayId %d configId %d", __FUNCTION__,
+          (uint32_t)mId, (uint32_t)configId);
+    *outConfig = configId;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getDisplayAttribute(hwc2_config_t configId,
+        int32_t attribute, int32_t* outValue) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (configId > mConfigs.size() || !mConfigs[configId]->isOnDisplay(*this)) {
+        ALOGW("%s: bad config (%u %u)", __FUNCTION__, (uint32_t)mId, configId);
+        return Error::BadConfig;
+    }
+    *outValue = mConfigs[configId]->getAttribute((Attribute)attribute);
+    ALOGV("%s: (%d %d) %s --> %d", __FUNCTION__,
+          (uint32_t)mId, (uint32_t)configId,
+          to_string((Attribute)attribute).c_str(), *outValue);
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getChangedCompositionTypes(
+        uint32_t* outNumElements, hwc2_layer_t* outLayers, int32_t* outTypes) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (!mChanges) {
+        ALOGW("display %u getChangedCompositionTypes failed: not validated",
+                (uint32_t)mId);
+        return Error::NotValidated;
+    }
+
+    if ((outLayers == nullptr) || (outTypes == nullptr)) {
+        *outNumElements = mChanges->getTypeChanges().size();
+        return Error::None;
+    }
+
+    uint32_t numWritten = 0;
+    for (const auto& element : mChanges->getTypeChanges()) {
+        if (numWritten == *outNumElements) {
+            break;
+        }
+        auto layerId = element.first;
+        auto intType = static_cast<int32_t>(element.second);
+        ALOGV("%s: Adding layer %u %s", __FUNCTION__, (uint32_t)layerId,
+                to_string(element.second).c_str());
+        outLayers[numWritten] = layerId;
+        outTypes[numWritten] = intType;
+        ++numWritten;
+    }
+    *outNumElements = numWritten;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getColorModes(uint32_t* outNumModes,
+        int32_t* outModes) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (!outModes) {
+        *outNumModes = mColorModes.size();
+        return Error::None;
+    }
+
+    // we only support HAL_COLOR_MODE_NATIVE so far
+    uint32_t numModes = std::min(*outNumModes,
+            static_cast<uint32_t>(mColorModes.size()));
+    std::copy_n(mColorModes.cbegin(), numModes, outModes);
+    *outNumModes = numModes;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getConfigs(uint32_t* outNumConfigs,
+        hwc2_config_t* outConfigs) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (!outConfigs) {
+        *outNumConfigs = mConfigs.size();
+        return Error::None;
+    }
+    uint32_t numWritten = 0;
+    for (const auto config : mConfigs) {
+        if (numWritten == *outNumConfigs) {
+            break;
+        }
+        outConfigs[numWritten] = config->getId();
+        ++numWritten;
+    }
+    *outNumConfigs = numWritten;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getDozeSupport(int32_t* outSupport) {
+    ALOGVV("%s", __FUNCTION__);
+    // We don't support so far
+    *outSupport = 0;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getHdrCapabilities(uint32_t* outNumTypes,
+        int32_t* /*outTypes*/, float* /*outMaxLuminance*/,
+        float* /*outMaxAverageLuminance*/, float* /*outMinLuminance*/) {
+    ALOGVV("%s", __FUNCTION__);
+    // We don't support so far
+    *outNumTypes = 0;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getName(uint32_t* outSize, char* outName) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (!outName) {
+        *outSize = mName.size();
+        return Error::None;
+    }
+    auto numCopied = mName.copy(outName, *outSize);
+    *outSize = numCopied;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getReleaseFences(uint32_t* outNumElements,
+        hwc2_layer_t* /*outLayers*/, int32_t* /*outFences*/) {
+    ALOGVV("%s", __FUNCTION__);
+
+    *outNumElements = 0;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getRequests(int32_t* outDisplayRequests,
+        uint32_t* outNumElements, hwc2_layer_t* outLayers,
+        int32_t* outLayerRequests) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (!mChanges) {
+        return Error::NotValidated;
+    }
+
+    if (outLayers == nullptr || outLayerRequests == nullptr) {
+        *outNumElements = mChanges->getNumLayerRequests();
+        return Error::None;
+    }
+
+    //TODO
+    // Display requests (HWC2::DisplayRequest) are not supported so far:
+    *outDisplayRequests = 0;
+
+    uint32_t numWritten = 0;
+    for (const auto& request : mChanges->getLayerRequests()) {
+        if (numWritten == *outNumElements) {
+            break;
+        }
+        outLayers[numWritten] = request.first;
+        outLayerRequests[numWritten] = static_cast<int32_t>(request.second);
+        ++numWritten;
+    }
+
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getType(int32_t* outType) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    *outType = (int32_t)mType;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::present(int32_t* outRetireFence) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (!mChanges || (mChanges->getNumTypes() > 0)) {
+        ALOGE("%s display(%u) set failed: not validated", __FUNCTION__,
+              (uint32_t)mId);
+        return Error::NotValidated;
+    }
+    mChanges.reset();
+
+    DEFINE_AND_VALIDATE_HOST_CONNECTION
+    if (rcEnc->hasHostCompositionV1()) {
+        uint32_t numLayer = 0;
+        for (auto layer: mLayers) {
+            if (layer->getCompositionType() == Composition::Device ||
+                layer->getCompositionType() == Composition::SolidColor) {
+                numLayer++;
+            }
+        }
+        ALOGV("present %d layers total %u layers", numLayer,
+              (uint32_t)mLayers.size());
+        if (numLayer == 0) {
+            mGralloc->getFb()->post(mGralloc->getFb(), mClientTarget.getBuffer());
+            *outRetireFence = mClientTarget.getFence();
+            return Error::None;
+        }
+
+        if (mComposeMsg == nullptr || mComposeMsg->getLayerCnt() < numLayer) {
+            mComposeMsg.reset(new ComposeMsg(numLayer));
+        }
+
+        // Handle the composition
+        ComposeDevice* p = mComposeMsg->get();
+        ComposeLayer* l = p->layer;
+        for (auto layer: mLayers) {
+            if (layer->getCompositionType() != Composition::Device &&
+                layer->getCompositionType() != Composition::SolidColor) {
+                ALOGE("%s: Unsupported composition types %d",
+                      __FUNCTION__, layer->getCompositionType());
+                continue;
+            }
+            // send layer composition command to host
+            if (layer->getCompositionType() == Composition::Device) {
+                int fence = layer->getLayerBuffer().getFence();
+                if (fence != -1) {
+                    int err = sync_wait(fence, 3000);
+                    if (err < 0 && errno == ETIME) {
+                        ALOGE("%s waited on fence %d for 3000 ms",
+                            __FUNCTION__, fence);
+                    }
+                }
+                else {
+                    ALOGV("%s: aquiredFence not set for layer %u",
+                          __FUNCTION__, (uint32_t)layer->getId());
+                }
+                cb_handle_t *cb =
+                    (cb_handle_t *)layer->getLayerBuffer().getBuffer();
+                if (cb != nullptr) {
+                    l->cbHandle = cb->hostHandle;
+                }
+                else {
+                    ALOGE("%s null buffer for layer %d", __FUNCTION__,
+                          (uint32_t)layer->getId());
+                }
+            }
+            else {
+                // solidcolor has no buffer
+                l->cbHandle = 0;
+            }
+            l->composeMode = (hwc2_composition_t)layer->getCompositionType();
+            l->displayFrame = layer->getDisplayFrame();
+            l->crop = layer->getSourceCrop();
+            l->blendMode = layer->getBlendMode();
+            l->alpha = layer->getPlaneAlpha();
+            l->color = layer->getColor();
+            l->transform = layer->getTransform();
+            ALOGV("   cb %d blendmode %d alpha %f %d %d %d %d z %d"
+                  " composeMode %d, transform %d",
+                  l->cbHandle, l->blendMode, l->alpha,
+                  l->displayFrame.left, l->displayFrame.top,
+                  l->displayFrame.right, l->displayFrame.bottom,
+                  layer->getZ(), l->composeMode, l->transform);
+            l++;
+        }
+        p->version = 1;
+        p->targetHandle = mGralloc->getTargetCb();
+        p->numLayers = numLayer;
+
+        rcEnc->rcCompose(rcEnc,
+                         sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer),
+                         (void *)p);
+        // not set retireFence should be fine, because the rcCompose is a
+        // sync call, it returns until the host call eglswapbuffers
+        *outRetireFence = -1;
+    }
+    else {
+        // we set all layers Composition::Client, so do nothing.
+        mGralloc->getFb()->post(mGralloc->getFb(), mClientTarget.getBuffer());
+        *outRetireFence = mClientTarget.getFence();
+        ALOGV("%s fallback to post, returns outRetireFence %d",
+              __FUNCTION__, *outRetireFence);
+    }
+
+    return Error::None;
+}
+
+Error EmuHWC2::Display::setActiveConfig(hwc2_config_t configId) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (configId > mConfigs.size() || !mConfigs[configId]->isOnDisplay(*this)) {
+        ALOGW("%s: bad config (%u %u)", __FUNCTION__, (uint32_t)mId,
+              (uint32_t)configId);
+        return Error::BadConfig;
+    }
+    auto config = mConfigs[configId];
+    if (config == mActiveConfig) {
+        return Error::None;
+    }
+
+    mActiveConfig = config;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::setClientTarget(buffer_handle_t target,
+        int32_t acquireFence, int32_t /*dataspace*/, hwc_region_t /*damage*/) {
+    ALOGVV("%s", __FUNCTION__);
+
+    cb_handle_t *cb =
+            (cb_handle_t *)target;
+    ALOGV("%s: display(%u) buffer handle %p cb %d, acquireFence %d", __FUNCTION__,
+          (uint32_t)mId, target, cb->hostHandle, acquireFence);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+    mClientTarget.setBuffer(target);
+    mClientTarget.setFence(acquireFence);
+    return Error::None;
+}
+
+Error EmuHWC2::Display::setColorMode(int32_t intMode) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    auto mode = static_cast<android_color_mode_t>(intMode);
+    ALOGV("%s: (display %u mode %d)", __FUNCTION__, (uint32_t)mId, intMode);
+    if (mode == mActiveColorMode) {
+        return Error::None;
+    }
+    if (mColorModes.count(mode) == 0) {
+        ALOGE("%s: display %d Mode %d not found in mColorModes",
+             __FUNCTION__, (uint32_t)mId, intMode);
+        return Error::Unsupported;
+    }
+    mActiveColorMode = mode;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::setColorTransform(const float* /*matrix*/,
+                                          int32_t hint) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+    //we force client composition if this is set
+    if (hint == 0 ) {
+        mSetColorTransform = false;
+    }
+    else {
+        mSetColorTransform = true;
+    }
+    return Error::None;
+}
+
+Error EmuHWC2::Display::setOutputBuffer(buffer_handle_t /*buffer*/,
+        int32_t /*releaseFence*/) {
+    ALOGVV("%s", __FUNCTION__);
+    //TODO: for virtual display
+    return Error::None;
+}
+
+static bool isValid(PowerMode mode) {
+    switch (mode) {
+        case PowerMode::Off: // Fall-through
+        case PowerMode::DozeSuspend: // Fall-through
+        case PowerMode::Doze: // Fall-through
+        case PowerMode::On: return true;
+        default: return false;
+    }
+}
+
+Error EmuHWC2::Display::setPowerMode(int32_t intMode) {
+    ALOGVV("%s", __FUNCTION__);
+    // Emulator always set screen ON
+    PowerMode mode = static_cast<PowerMode>(intMode);
+    if (!isValid(mode)) {
+        return Error::BadParameter;
+    }
+    if (mode == mPowerMode) {
+        return Error::None;
+    }
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    ALOGV("%s: (display %u mode %s)", __FUNCTION__,
+          (uint32_t)mId, to_string(mode).c_str());
+    mPowerMode = mode;
+    return Error::None;
+}
+
+static bool isValid(Vsync enable) {
+    switch (enable) {
+        case Vsync::Enable: // Fall-through
+        case Vsync::Disable: return true;
+        case Vsync::Invalid: return false;
+    }
+}
+
+Error EmuHWC2::Display::setVsyncEnabled(int32_t intEnable) {
+    ALOGVV("%s", __FUNCTION__);
+    Vsync enable = static_cast<Vsync>(intEnable);
+    if (!isValid(enable)) {
+        return Error::BadParameter;
+    }
+    if (enable == mVsyncEnabled) {
+        return Error::None;
+    }
+
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    mVsyncEnabled = enable;
+    return Error::None;
+}
+
+Error EmuHWC2::Display::validate(uint32_t* outNumTypes,
+        uint32_t* outNumRequests) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (!mChanges) {
+        mChanges.reset(new Changes);
+        DEFINE_AND_VALIDATE_HOST_CONNECTION
+        if (rcEnc->hasHostCompositionV1()) {
+            // Support Device and SolidColor, otherwise, fallback all layers
+            // to Client
+            bool fallBack = false;
+            for (auto& layer : mLayers) {
+                if (layer->getCompositionType() == Composition::Client ||
+                    layer->getCompositionType() == Composition::Cursor ||
+                    layer->getCompositionType() == Composition::Sideband) {
+                    ALOGV("%s: layer %u CompositionType %d\n", __FUNCTION__,
+                         (uint32_t)layer->getId(), layer->getCompositionType());
+                    fallBack = true;
+                    break;
+                }
+            }
+            if (mSetColorTransform) {
+                fallBack = true;
+            }
+            if (fallBack) {
+                for (auto& layer : mLayers) {
+                    if (layer->getCompositionType() != Composition::Client) {
+                        mChanges->addTypeChange(layer->getId(),
+                                                Composition::Client);
+                    }
+                }
+            }
+       }
+       else {
+            for (auto& layer : mLayers) {
+                if (layer->getCompositionType() != Composition::Client) {
+                    mChanges->addTypeChange(layer->getId(),
+                                            Composition::Client);
+                }
+            }
+        }
+    }
+    else {
+        ALOGE("Validate was called more than once!");
+    }
+
+    *outNumTypes = mChanges->getNumTypes();
+    *outNumRequests = mChanges->getNumLayerRequests();
+    ALOGV("%s: displayId %u types %u, requests %u", __FUNCTION__,
+          (uint32_t)mId, *outNumTypes, *outNumRequests);
+    return *outNumTypes > 0 ? Error::HasChanges : Error::None;
+}
+
+Error EmuHWC2::Display::updateLayerZ(hwc2_layer_t layerId, uint32_t z) {
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    const auto mapLayer = mDevice.mLayers.find(layerId);
+    if (mapLayer == mDevice.mLayers.end()) {
+        ALOGE("%s failed to find layer %u", __FUNCTION__, (uint32_t)mId);
+        return Error::BadLayer;
+    }
+
+    const auto layer = mapLayer->second;
+    const auto zRange = mLayers.equal_range(layer);
+    bool layerOnDisplay = false;
+    for (auto current = zRange.first; current != zRange.second; ++current) {
+        if (**current == *layer) {
+            if ((*current)->getZ() == z) {
+                // Don't change anything if the Z hasn't changed
+                return Error::None;
+            }
+            current = mLayers.erase(current);
+            layerOnDisplay = true;
+            break;
+        }
+    }
+
+    if (!layerOnDisplay) {
+        ALOGE("%s failed to find layer %u on display", __FUNCTION__,
+              (uint32_t)mId);
+        return Error::BadLayer;
+    }
+
+    layer->setZ(z);
+    mLayers.emplace(std::move(layer));
+    return Error::None;
+}
+
+Error EmuHWC2::Display::getClientTargetSupport(uint32_t width, uint32_t height,
+                                      int32_t format, int32_t dataspace){
+    ALOGVV("%s", __FUNCTION__);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    if (mActiveConfig == nullptr) {
+        return Error::Unsupported;
+    }
+
+    if (width == (uint32_t)mActiveConfig->getAttribute(Attribute::Width) &&
+        height == (uint32_t)mActiveConfig->getAttribute(Attribute::Height) &&
+        format == HAL_PIXEL_FORMAT_RGBA_8888 &&
+        dataspace == HAL_DATASPACE_UNKNOWN) {
+        return Error::None;
+    }
+
+    return Error::None;
+}
+
+
+int EmuHWC2::Display::populatePrimaryConfigs() {
+    ALOGVV("%s DisplayId %u", __FUNCTION__, (uint32_t)mId);
+    std::unique_lock<std::mutex> lock(mStateMutex);
+
+    mGralloc.reset(new GrallocModule());
+    auto newConfig = std::make_shared<Config>(*this);
+    // vsync is 60 hz;
+    newConfig->setAttribute(Attribute::VsyncPeriod, mVsyncPeriod);
+    newConfig->setAttribute(Attribute::Width, mGralloc->getFb()->width);
+    newConfig->setAttribute(Attribute::Height, mGralloc->getFb()->height);
+    newConfig->setAttribute(Attribute::DpiX, mGralloc->getFb()->xdpi*1000);
+    newConfig->setAttribute(Attribute::DpiY, mGralloc->getFb()->ydpi*1000);
+
+    newConfig->setId(static_cast<hwc2_config_t>(mConfigs.size()));
+    ALOGV("Found new config %d: %s", (uint32_t)newConfig->getId(),
+            newConfig->toString().c_str());
+    mConfigs.emplace_back(std::move(newConfig));
+
+    // Only have single config so far, it is activeConfig
+    mActiveConfig = mConfigs[0];
+    mActiveColorMode = HAL_COLOR_MODE_NATIVE;
+    mColorModes.emplace((android_color_mode_t)HAL_COLOR_MODE_NATIVE);
+
+    return 0;
+}
+
+
+// Config functions
+
+void EmuHWC2::Display::Config::setAttribute(Attribute attribute,
+       int32_t value) {
+    mAttributes[attribute] = value;
+}
+
+int32_t EmuHWC2::Display::Config::getAttribute(Attribute attribute) const {
+    if (mAttributes.count(attribute) == 0) {
+        return -1;
+    }
+    return mAttributes.at(attribute);
+}
+
+std::string EmuHWC2::Display::Config::toString() const {
+    std::string output;
+
+    const size_t BUFFER_SIZE = 100;
+    char buffer[BUFFER_SIZE] = {};
+    auto writtenBytes = snprintf(buffer, BUFFER_SIZE,
+            "%u x %u", mAttributes.at(HWC2::Attribute::Width),
+            mAttributes.at(HWC2::Attribute::Height));
+    output.append(buffer, writtenBytes);
+
+    if (mAttributes.count(HWC2::Attribute::VsyncPeriod) != 0) {
+        std::memset(buffer, 0, BUFFER_SIZE);
+        writtenBytes = snprintf(buffer, BUFFER_SIZE, " @ %.1f Hz",
+                1e9 / mAttributes.at(HWC2::Attribute::VsyncPeriod));
+        output.append(buffer, writtenBytes);
+    }
+
+    if (mAttributes.count(HWC2::Attribute::DpiX) != 0 &&
+            mAttributes.at(HWC2::Attribute::DpiX) != -1) {
+        std::memset(buffer, 0, BUFFER_SIZE);
+        writtenBytes = snprintf(buffer, BUFFER_SIZE,
+                ", DPI: %.1f x %.1f",
+                mAttributes.at(HWC2::Attribute::DpiX) / 1000.0f,
+                mAttributes.at(HWC2::Attribute::DpiY) / 1000.0f);
+        output.append(buffer, writtenBytes);
+    }
+
+    return output;
+}
+
+
+// VsyncThread function
+bool EmuHWC2::Display::VsyncThread::threadLoop() {
+    struct timespec rt;
+    if (clock_gettime(CLOCK_MONOTONIC, &rt) == -1) {
+        ALOGE("%s: error in vsync thread clock_gettime: %s",
+              __FUNCTION__, strerror(errno));
+        return true;
+    }
+    const int logInterval = 60;
+    int64_t lastLogged = rt.tv_sec;
+    int sent = 0;
+    int lastSent = 0;
+    bool vsyncEnabled = false;
+    struct timespec wait_time;
+    wait_time.tv_sec = 0;
+    wait_time.tv_nsec = mDisplay.mVsyncPeriod;
+
+    while (true) {
+        int err = nanosleep(&wait_time, NULL);
+        if (err == -1) {
+            if (errno == EINTR) {
+                break;
+            }
+            ALOGE("%s: error in vsync thread: %s", __FUNCTION__, strerror(errno));
+        }
+
+        std::unique_lock<std::mutex> lock(mDisplay.mStateMutex);
+        vsyncEnabled = (mDisplay.mVsyncEnabled == Vsync::Enable);
+        lock.unlock();
+
+        if (!vsyncEnabled) {
+            continue;
+        }
+
+        if (clock_gettime(CLOCK_MONOTONIC, &rt) == -1) {
+            ALOGE("%s: error in vsync thread clock_gettime: %s",
+                 __FUNCTION__, strerror(errno));
+        }
+
+        int64_t timestamp = int64_t(rt.tv_sec) * 1e9 + rt.tv_nsec;
+
+        lock.lock();
+        const auto& callbackInfo = mDisplay.mDevice.mCallbacks[Callback::Vsync];
+        auto vsync = reinterpret_cast<HWC2_PFN_VSYNC>(callbackInfo.pointer);
+        lock.unlock();
+
+        if (vsync) {
+            vsync(callbackInfo.data, mDisplay.mId, timestamp);
+        }
+
+        if (rt.tv_sec - lastLogged >= logInterval) {
+            ALOGVV("sent %d syncs in %ds", sent - lastSent, rt.tv_sec - lastLogged);
+            lastLogged = rt.tv_sec;
+            lastSent = sent;
+        }
+        ++sent;
+    }
+    return false;
+}
+
+
+// Layer functions
+bool EmuHWC2::SortLayersByZ::operator()(
+        const std::shared_ptr<Layer>& lhs, const std::shared_ptr<Layer>& rhs) {
+    return lhs->getZ() < rhs->getZ();
+}
+
+std::atomic<hwc2_layer_t> EmuHWC2::Layer::sNextId(1);
+
+EmuHWC2::Layer::Layer(Display& display)
+  : mId(sNextId++),
+    mDisplay(display),
+    mBuffer(),
+    mSurfaceDamage(),
+    mBlendMode(BlendMode::None),
+    mColor({0, 0, 0, 0}),
+    mCompositionType(Composition::Invalid),
+    mDisplayFrame({0, 0, -1, -1}),
+    mPlaneAlpha(0.0f),
+    mSidebandStream(nullptr),
+    mSourceCrop({0.0f, 0.0f, -1.0f, -1.0f}),
+    mTransform(Transform::None),
+    mVisibleRegion(),
+    mZ(0)
+    {}
+
+Error EmuHWC2::Layer::setBuffer(buffer_handle_t buffer,
+        int32_t acquireFence) {
+    ALOGVV("%s: Setting acquireFence %d for layer %u", __FUNCTION__,
+          acquireFence, (uint32_t)mId);
+    mBuffer.setBuffer(buffer);
+    mBuffer.setFence(acquireFence);
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setCursorPosition(int32_t /*x*/,
+                                        int32_t /*y*/) {
+    ALOGVV("%s", __FUNCTION__);
+    if (mCompositionType != Composition::Cursor) {
+        return Error::BadLayer;
+    }
+   //TODO
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setSurfaceDamage(hwc_region_t /*damage*/) {
+    // Emulator redraw whole layer per frame, so ignore this.
+    return Error::None;
+}
+
+// Layer state functions
+
+Error EmuHWC2::Layer::setBlendMode(int32_t mode) {
+    ALOGVV("%s %d for layer %u", __FUNCTION__, mode, (uint32_t)mId);
+    mBlendMode = static_cast<BlendMode>(mode);
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setColor(hwc_color_t color) {
+    ALOGVV("%s", __FUNCTION__);
+    mColor = color;
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setCompositionType(int32_t type) {
+    ALOGVV("%s", __FUNCTION__);
+    mCompositionType = static_cast<Composition>(type);
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setDataspace(int32_t) {
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setDisplayFrame(hwc_rect_t frame) {
+    mDisplayFrame = frame;
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setPlaneAlpha(float alpha) {
+    mPlaneAlpha = alpha;
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setSidebandStream(const native_handle_t* stream) {
+    mSidebandStream = stream;
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setSourceCrop(hwc_frect_t crop) {
+    mSourceCrop = crop;
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setTransform(int32_t transform) {
+    mTransform = static_cast<Transform>(transform);
+    return Error::None;
+}
+
+static bool compareRects(const hwc_rect_t& rect1, const hwc_rect_t& rect2) {
+    return rect1.left == rect2.left &&
+            rect1.right == rect2.right &&
+            rect1.top == rect2.top &&
+            rect1.bottom == rect2.bottom;
+}
+
+Error EmuHWC2::Layer::setVisibleRegion(hwc_region_t visible) {
+    ALOGVV("%s", __FUNCTION__);
+    if ((getNumVisibleRegions() != visible.numRects) ||
+        !std::equal(mVisibleRegion.begin(), mVisibleRegion.end(), visible.rects,
+                    compareRects)) {
+        mVisibleRegion.resize(visible.numRects);
+        std::copy_n(visible.rects, visible.numRects, mVisibleRegion.begin());
+    }
+    return Error::None;
+}
+
+Error EmuHWC2::Layer::setZ(uint32_t z) {
+    ALOGVV("%s %d", __FUNCTION__, z);
+    mZ = z;
+    return Error::None;
+}
+
+// Adaptor Helpers
+
+void EmuHWC2::populateCapabilities() {
+    //TODO: add Capabilities
+    // support virtualDisplay
+    // support sideBandStream
+    // support backGroundColor
+    // we should not set this for HWC2, TODO: remove
+    // mCapabilities.insert(Capability::PresentFenceIsNotReliable);
+}
+
+int EmuHWC2::populatePrimary() {
+    int ret = 0;
+    auto display = std::make_shared<Display>(*this, HWC2::DisplayType::Physical);
+    ret = display->populatePrimaryConfigs();
+    if (ret != 0) {
+        return ret;
+    }
+    mDisplays.emplace(display->getId(), std::move(display));
+    return ret;
+}
+
+EmuHWC2::Display* EmuHWC2::getDisplay(hwc2_display_t id) {
+    auto display = mDisplays.find(id);
+    if (display == mDisplays.end()) {
+        return nullptr;
+    }
+    return display->second.get();
+}
+
+std::tuple<EmuHWC2::Layer*, Error> EmuHWC2::getLayer(
+        hwc2_display_t displayId, hwc2_layer_t layerId) {
+    auto display = getDisplay(displayId);
+    if (!display) {
+        ALOGE("%s: Fail to find display %d", __FUNCTION__, (uint32_t)displayId);
+        return std::make_tuple(static_cast<Layer*>(nullptr), Error::BadDisplay);
+    }
+
+    auto layerEntry = mLayers.find(layerId);
+    if (layerEntry == mLayers.end()) {
+        ALOGE("%s: Fail to find layer %d", __FUNCTION__, (uint32_t)layerId);
+        return std::make_tuple(static_cast<Layer*>(nullptr), Error::BadLayer);
+    }
+
+    auto layer = layerEntry->second;
+    if (layer->getDisplay().getId() != displayId) {
+        ALOGE("%s: layer %d not belongs to display %d", __FUNCTION__,
+              (uint32_t)layerId, (uint32_t)displayId);
+        return std::make_tuple(static_cast<Layer*>(nullptr), Error::BadLayer);
+    }
+    return std::make_tuple(layer.get(), Error::None);
+}
+
+static int hwc2DevOpen(const struct hw_module_t *module, const char *name,
+        struct hw_device_t **dev) {
+    ALOGV("%s ", __FUNCTION__);
+    if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
+        ALOGE("Invalid module name- %s", name);
+        return -EINVAL;
+    }
+
+    EmuHWC2* ctx = new EmuHWC2();
+    if (!ctx) {
+        ALOGE("Failed to allocate EmuHWC2");
+        return -ENOMEM;
+    }
+    int ret = ctx->populatePrimary();
+    if (ret != 0) {
+        ALOGE("Failed to populate primary display");
+        return ret;
+    }
+
+    ctx->common.module = const_cast<hw_module_t *>(module);
+    *dev = &ctx->common;
+    return 0;
+}
+}
+
+static struct hw_module_methods_t hwc2_module_methods = {
+    .open = android::hwc2DevOpen
+};
+
+hw_module_t HAL_MODULE_INFO_SYM = {
+    .tag = HARDWARE_MODULE_TAG,
+    .version_major = 2,
+    .version_minor = 0,
+    .id = HWC_HARDWARE_MODULE_ID,
+    .name = "goldfish HWC2 module",
+    .author = "The Android Open Source Project",
+    .methods = &hwc2_module_methods,
+    .dso = NULL,
+    .reserved = {0},
+};
diff --git a/system/hwc2/EmuHWC2.h b/system/hwc2/EmuHWC2.h
new file mode 100644
index 0000000..0d768dd
--- /dev/null
+++ b/system/hwc2/EmuHWC2.h
@@ -0,0 +1,448 @@
+/*
+ * Copyright 2018 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 ANDROID_HW_EMU_HWC2_H
+#define ANDROID_HW_EMU_HWC2_H
+
+#define HWC2_INCLUDE_STRINGIFICATION
+#define HWC2_USE_CPP11
+#include <hardware/hwcomposer2.h>
+#undef HWC2_INCLUDE_STRINGIFICATION
+#undef HWC2_USE_CPP11
+#include <utils/Thread.h>
+
+#include <atomic>
+#include <map>
+#include <mutex>
+#include <vector>
+#include <unordered_set>
+#include <unordered_map>
+#include <set>
+
+#include "gralloc_cb.h"
+#include "MiniFence.h"
+#include "HostConnection.h"
+
+namespace android {
+
+class EmuHWC2 : public hwc2_device_t {
+public:
+    EmuHWC2();
+    int populatePrimary();
+
+private:
+    static inline EmuHWC2* getHWC2(hwc2_device_t* device) {
+        return static_cast<EmuHWC2*>(device);
+    }
+
+    static int closeHook(hw_device_t* device) {
+        EmuHWC2 *ctx = reinterpret_cast<EmuHWC2*>(device);
+        delete ctx;
+        return 0;
+    }
+
+    // getCapabilities
+    void doGetCapabilities(uint32_t* outCount, int32_t* outCapabilities);
+    static void getCapabilitiesHook(hwc2_device_t* device, uint32_t* outCount,
+                                int32_t* outCapabilities) {
+        getHWC2(device)->doGetCapabilities(outCount, outCapabilities);
+    }
+
+    // getFunction
+    hwc2_function_pointer_t doGetFunction(HWC2::FunctionDescriptor descriptor);
+    static hwc2_function_pointer_t getFunctionHook(hwc2_device_t* device,
+            int32_t desc) {
+        auto descriptor = static_cast<HWC2::FunctionDescriptor>(desc);
+        return getHWC2(device)->doGetFunction(descriptor);
+    }
+
+    // Device functions
+    HWC2::Error createVirtualDisplay(uint32_t width, uint32_t height,
+            int32_t* format, hwc2_display_t* outDisplay);
+    static int32_t createVirtualDisplayHook(hwc2_device_t* device,
+            uint32_t width, uint32_t height, int32_t* format,
+            hwc2_display_t* outDisplay) {
+        auto error = getHWC2(device)->createVirtualDisplay(width, height,
+                format, outDisplay);
+        return static_cast<int32_t>(error);
+    }
+
+    HWC2::Error destroyVirtualDisplay(hwc2_display_t display);
+    static int32_t destroyVirtualDisplayHook(hwc2_device_t* device,
+            hwc2_display_t display) {
+        auto error = getHWC2(device)->destroyVirtualDisplay(display);
+        return static_cast<int32_t>(error);
+    }
+
+    std::string mDumpString;
+    void dump(uint32_t* outSize, char* outBuffer);
+    static void dumpHook(hwc2_device_t* device, uint32_t* outSize,
+            char* outBuffer) {
+        getHWC2(device)->dump(outSize, outBuffer);
+    }
+
+    uint32_t getMaxVirtualDisplayCount();
+    static uint32_t getMaxVirtualDisplayCountHook(hwc2_device_t* device) {
+        return getHWC2(device)->getMaxVirtualDisplayCount();
+    }
+
+    HWC2::Error registerCallback(HWC2::Callback descriptor,
+            hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer);
+    static int32_t registerCallbackHook(hwc2_device_t* device,
+            int32_t intDesc, hwc2_callback_data_t callbackData,
+            hwc2_function_pointer_t pointer) {
+        auto descriptor = static_cast<HWC2::Callback>(intDesc);
+        auto error = getHWC2(device)->registerCallback(descriptor,
+                callbackData, pointer);
+        return static_cast<int32_t>(error);
+    }
+
+    class Layer;
+    class SortLayersByZ {
+    public:
+        bool operator()(const std::shared_ptr<Layer>& lhs,
+                    const std::shared_ptr<Layer>& rhs);
+    };
+
+    // SurfaceFlinger sets the ColorBuffer and its Fence handler for each
+    // layer. This class is a container for these two.
+    class FencedBuffer {
+        public:
+            FencedBuffer() : mBuffer(nullptr), mFence(MiniFence::NO_FENCE) {}
+
+            void setBuffer(buffer_handle_t buffer) { mBuffer = buffer; }
+            void setFence(int fenceFd) { mFence = new MiniFence(fenceFd); }
+
+            buffer_handle_t getBuffer() const { return mBuffer; }
+            int getFence() const { return mFence->dup(); }
+
+        private:
+            buffer_handle_t mBuffer;
+            sp<MiniFence> mFence;
+    };
+
+    class GrallocModule {
+    public:
+        GrallocModule();
+        ~GrallocModule();
+        framebuffer_device_t* getFb() { return mFbDev; }
+        uint32_t getTargetCb();
+    private:
+        const hw_module_t* mHw = nullptr;
+        const gralloc_module_t* mGralloc = nullptr;
+        alloc_device_t* mAllocDev = nullptr;
+        framebuffer_device_t* mFbDev = nullptr;
+        buffer_handle_t mHandle = nullptr;
+    };
+
+    typedef struct compose_layer {
+        uint32_t cbHandle;
+        hwc2_composition_t composeMode;
+        hwc_rect_t displayFrame;
+        hwc_frect_t crop;
+        int32_t blendMode;
+        float alpha;
+        hwc_color_t color;
+        hwc_transform_t transform;
+    } ComposeLayer;
+    typedef struct compose_device {
+        uint32_t version;
+        uint32_t targetHandle;
+        uint32_t numLayers;
+        struct compose_layer layer[0];
+    } ComposeDevice;
+
+    class ComposeMsg {
+    public:
+        ComposeMsg(uint32_t layerCnt = 0) :
+          mData(sizeof(ComposeDevice) + layerCnt * sizeof(ComposeLayer))
+        {
+            mComposeDevice = reinterpret_cast<ComposeDevice*>(mData.data());
+            mLayerCnt = layerCnt;
+        }
+
+        ComposeDevice* get() { return mComposeDevice; }
+
+        uint32_t getLayerCnt() { return mLayerCnt; }
+
+    private:
+        std::vector<uint8_t> mData;
+        uint32_t mLayerCnt;
+        ComposeDevice* mComposeDevice;
+    };
+
+    class Display {
+    public:
+        Display(EmuHWC2& device, HWC2::DisplayType type);
+        hwc2_display_t getId() const {return mId;}
+
+        // HWC2 Display functions
+        HWC2::Error acceptChanges();
+        HWC2::Error createLayer(hwc2_layer_t* outLayerId);
+        HWC2::Error destroyLayer(hwc2_layer_t layerId);
+        HWC2::Error getActiveConfig(hwc2_config_t* outConfigId);
+        HWC2::Error getDisplayAttribute(hwc2_config_t configId,
+                int32_t attribute, int32_t* outValue);
+        HWC2::Error getChangedCompositionTypes(uint32_t* outNumElements,
+                hwc2_layer_t* outLayers, int32_t* outTypes);
+        HWC2::Error getColorModes(uint32_t* outNumModes, int32_t* outModes);
+        HWC2::Error getConfigs(uint32_t* outNumConfigs,
+                hwc2_config_t* outConfigIds);
+        HWC2::Error getDozeSupport(int32_t* outSupport);
+        HWC2::Error getHdrCapabilities(uint32_t* outNumTypes,
+                int32_t* outTypes, float* outMaxLuminance,
+                float* outMaxAverageLuminance, float* outMinLuminance);
+        HWC2::Error getName(uint32_t* outSize, char* outName);
+        HWC2::Error getReleaseFences(uint32_t* outNumElements,
+                hwc2_layer_t* outLayers, int32_t* outFences);
+        HWC2::Error getRequests(int32_t* outDisplayRequests,
+                uint32_t* outNumElements, hwc2_layer_t* outLayers,
+                int32_t* outLayerRequests);
+        HWC2::Error getType(int32_t* outType);
+        HWC2::Error present(int32_t* outRetireFence);
+        HWC2::Error setActiveConfig(hwc2_config_t configId);
+        HWC2::Error setClientTarget(buffer_handle_t target,
+                int32_t acquireFence, int32_t dataspace,
+                hwc_region_t damage);
+        HWC2::Error setColorMode(int32_t mode);
+        HWC2::Error setColorTransform(const float* matrix,
+                int32_t hint);
+        HWC2::Error setOutputBuffer(buffer_handle_t buffer,
+                int32_t releaseFence);
+        HWC2::Error setPowerMode(int32_t mode);
+        HWC2::Error setVsyncEnabled(int32_t enabled);
+        HWC2::Error validate(uint32_t* outNumTypes,
+                uint32_t* outNumRequests);
+        HWC2::Error updateLayerZ(hwc2_layer_t layerId, uint32_t z);
+        HWC2::Error getClientTargetSupport(uint32_t width, uint32_t height,
+                 int32_t format, int32_t dataspace);
+
+        // Read configs from PRIMARY Display
+        int populatePrimaryConfigs();
+
+    private:
+        class Config {
+        public:
+            Config(Display& display)
+              : mDisplay(display),
+                mId(0),
+                mAttributes() {}
+
+            bool isOnDisplay(const Display& display) const {
+                return display.getId() == mDisplay.getId();
+            }
+            void setAttribute(HWC2::Attribute attribute, int32_t value);
+            int32_t getAttribute(HWC2::Attribute attribute) const;
+            void setId(hwc2_config_t id) {mId = id; }
+            hwc2_config_t getId() const {return mId; }
+            std::string toString() const;
+
+        private:
+            Display& mDisplay;
+            hwc2_config_t mId;
+            std::unordered_map<HWC2::Attribute, int32_t> mAttributes;
+        };
+
+        // Stores changes requested from the device upon calling prepare().
+        // Handles change request to:
+        //   - Layer composition type.
+        //   - Layer hints.
+        class Changes {
+            public:
+                uint32_t getNumTypes() const {
+                    return static_cast<uint32_t>(mTypeChanges.size());
+                }
+
+                uint32_t getNumLayerRequests() const {
+                    return static_cast<uint32_t>(mLayerRequests.size());
+                }
+
+                const std::unordered_map<hwc2_layer_t, HWC2::Composition>&
+                        getTypeChanges() const {
+                    return mTypeChanges;
+                }
+
+                const std::unordered_map<hwc2_layer_t, HWC2::LayerRequest>&
+                        getLayerRequests() const {
+                    return mLayerRequests;
+                }
+
+                void addTypeChange(hwc2_layer_t layerId,
+                        HWC2::Composition type) {
+                    mTypeChanges.insert({layerId, type});
+                }
+
+                void clearTypeChanges() { mTypeChanges.clear(); }
+
+                void addLayerRequest(hwc2_layer_t layerId,
+                        HWC2::LayerRequest request) {
+                    mLayerRequests.insert({layerId, request});
+                }
+
+            private:
+                std::unordered_map<hwc2_layer_t, HWC2::Composition>
+                        mTypeChanges;
+                std::unordered_map<hwc2_layer_t, HWC2::LayerRequest>
+                        mLayerRequests;
+        };
+
+        // Generate sw vsync signal
+        class VsyncThread : public Thread {
+        public:
+            VsyncThread(Display& display)
+              : mDisplay(display) {}
+            virtual ~VsyncThread() {}
+        private:
+            Display& mDisplay;
+            bool threadLoop() final;
+        };
+
+    private:
+        EmuHWC2& mDevice;
+        // Display ID generator.
+        static std::atomic<hwc2_display_t> sNextId;
+        const hwc2_display_t mId;
+        std::string mName;
+        HWC2::DisplayType mType;
+        HWC2::PowerMode mPowerMode;
+        HWC2::Vsync mVsyncEnabled;
+        uint32_t mVsyncPeriod;
+        VsyncThread mVsyncThread;
+        FencedBuffer mClientTarget;
+        // Will only be non-null after the Display has been validated and
+        // before it has been presented
+        std::unique_ptr<Changes> mChanges;
+        // All layers this Display is aware of.
+        std::multiset<std::shared_ptr<Layer>, SortLayersByZ> mLayers;
+        std::vector<std::shared_ptr<Config>> mConfigs;
+        std::shared_ptr<const Config> mActiveConfig;
+        std::set<android_color_mode_t> mColorModes;
+        android_color_mode_t mActiveColorMode;
+        bool mSetColorTransform;
+        // The state of this display should only be modified from
+        // SurfaceFlinger's main loop, with the exception of when dump is
+        // called. To prevent a bad state from crashing us during a dump
+        // call, all public calls into Display must acquire this mutex.
+        mutable std::mutex mStateMutex;
+        std::unique_ptr<GrallocModule> mGralloc;
+        std::unique_ptr<ComposeMsg> mComposeMsg;
+   };
+
+    template<typename MF, MF memFunc, typename ...Args>
+    static int32_t displayHook(hwc2_device_t* device, hwc2_display_t displayId,
+            Args... args) {
+        auto display = getHWC2(device)->getDisplay(displayId);
+        if (!display) {
+            return static_cast<int32_t>(HWC2::Error::BadDisplay);
+        }
+        auto error = ((*display).*memFunc)(std::forward<Args>(args)...);
+        return static_cast<int32_t>(error);
+    }
+
+    class Layer {
+    public:
+        explicit Layer(Display& display);
+        Display& getDisplay() const {return mDisplay;}
+        hwc2_layer_t getId() const {return mId;}
+        bool operator==(const Layer& other) { return mId == other.mId; }
+        bool operator!=(const Layer& other) { return !(*this == other); }
+
+        // HWC2 Layer functions
+        HWC2::Error setBuffer(buffer_handle_t buffer, int32_t acquireFence);
+        HWC2::Error setCursorPosition(int32_t x, int32_t y);
+        HWC2::Error setSurfaceDamage(hwc_region_t damage);
+
+        // HWC2 Layer state functions
+        HWC2::Error setBlendMode(int32_t mode);
+        HWC2::Error setColor(hwc_color_t color);
+        HWC2::Error setCompositionType(int32_t type);
+        HWC2::Error setDataspace(int32_t dataspace);
+        HWC2::Error setDisplayFrame(hwc_rect_t frame);
+        HWC2::Error setPlaneAlpha(float alpha);
+        HWC2::Error setSidebandStream(const native_handle_t* stream);
+        HWC2::Error setSourceCrop(hwc_frect_t crop);
+        HWC2::Error setTransform(int32_t transform);
+        HWC2::Error setVisibleRegion(hwc_region_t visible);
+        HWC2::Error setZ(uint32_t z);
+
+        HWC2::Composition getCompositionType() const {
+            return mCompositionType;
+        }
+        hwc_color_t getColor() {return mColor; }
+        uint32_t getZ() {return mZ; }
+        std::size_t getNumVisibleRegions() {return mVisibleRegion.size(); }
+        FencedBuffer& getLayerBuffer() {return mBuffer; }
+        int32_t getBlendMode() {return (int32_t)mBlendMode; }
+        float getPlaneAlpha() {return mPlaneAlpha; }
+        hwc_frect_t getSourceCrop() {return mSourceCrop; }
+        hwc_rect_t getDisplayFrame() {return mDisplayFrame; }
+        hwc_transform_t getTransform() {return (hwc_transform_t)mTransform; }
+    private:
+        static std::atomic<hwc2_layer_t> sNextId;
+        const hwc2_layer_t mId;
+        Display& mDisplay;
+        FencedBuffer mBuffer;
+        std::vector<hwc_rect_t> mSurfaceDamage;
+
+        HWC2::BlendMode mBlendMode;
+        hwc_color_t mColor;
+        HWC2::Composition mCompositionType;
+        hwc_rect_t mDisplayFrame;
+        float mPlaneAlpha;
+        const native_handle_t* mSidebandStream;
+        hwc_frect_t mSourceCrop;
+        HWC2::Transform mTransform;
+        std::vector<hwc_rect_t> mVisibleRegion;
+        uint32_t mZ;
+    };
+
+    template <typename MF, MF memFunc, typename ...Args>
+    static int32_t layerHook(hwc2_device_t* device, hwc2_display_t displayId,
+            hwc2_layer_t layerId, Args... args) {
+        auto result = getHWC2(device)->getLayer(displayId, layerId);
+        auto error = std::get<HWC2::Error>(result);
+        if (error == HWC2::Error::None) {
+            auto layer = std::get<Layer*>(result);
+            error = ((*layer).*memFunc)(std::forward<Args>(args)...);
+        }
+        return static_cast<int32_t>(error);
+    }
+
+    // helpers
+    void populateCapabilities();
+    Display* getDisplay(hwc2_display_t id);
+    std::tuple<Layer*, HWC2::Error> getLayer(hwc2_display_t displayId,
+            hwc2_layer_t layerId);
+
+    std::unordered_set<HWC2::Capability> mCapabilities;
+
+    // These are potentially accessed from multiple threads, and are protected
+    // by this mutex.
+    std::mutex mStateMutex;
+
+    struct CallbackInfo {
+        hwc2_callback_data_t data;
+        hwc2_function_pointer_t pointer;
+    };
+    std::unordered_map<HWC2::Callback, CallbackInfo> mCallbacks;
+
+    std::unordered_map<hwc2_display_t, std::shared_ptr<Display>> mDisplays;
+    std::unordered_map<hwc2_layer_t, std::shared_ptr<Layer>> mLayers;
+
+};
+
+}
+#endif
diff --git a/system/hwc2/MiniFence.cpp b/system/hwc2/MiniFence.cpp
new file mode 100644
index 0000000..ecfb063
--- /dev/null
+++ b/system/hwc2/MiniFence.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 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 "MiniFence.h"
+
+#include <unistd.h>
+
+namespace android {
+
+const sp<MiniFence> MiniFence::NO_FENCE = sp<MiniFence>(new MiniFence);
+
+MiniFence::MiniFence() :
+    mFenceFd(-1) {
+}
+
+MiniFence::MiniFence(int fenceFd) :
+    mFenceFd(fenceFd) {
+}
+
+MiniFence::~MiniFence() {
+    if (mFenceFd != -1) {
+        close(mFenceFd);
+    }
+}
+
+int MiniFence::dup() const {
+    return ::dup(mFenceFd);
+}
+}
diff --git a/system/hwc2/MiniFence.h b/system/hwc2/MiniFence.h
new file mode 100644
index 0000000..31c9536
--- /dev/null
+++ b/system/hwc2/MiniFence.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2017 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 EMU_HWC2_MINIFENCE_H
+#define EMU_HWC2_MINIFENCE_H
+
+#include <utils/RefBase.h>
+
+namespace android {
+
+/* MiniFence is a minimal re-implementation of Fence from libui. It exists to
+ * avoid linking the HWC2on1Adapter to libui and satisfy Treble requirements.
+ */
+class MiniFence : public LightRefBase<MiniFence> {
+public:
+    static const sp<MiniFence> NO_FENCE;
+
+    // Construct a new MiniFence object with an invalid file descriptor.
+    MiniFence();
+
+    // Construct a new MiniFence object to manage a given fence file descriptor.
+    // When the new MiniFence object is destructed the file descriptor will be
+    // closed.
+    explicit MiniFence(int fenceFd);
+
+    // Not copyable or movable.
+    MiniFence(const MiniFence& rhs) = delete;
+    MiniFence& operator=(const MiniFence& rhs) = delete;
+    MiniFence(MiniFence&& rhs) = delete;
+    MiniFence& operator=(MiniFence&& rhs) = delete;
+
+    // Return a duplicate of the fence file descriptor. The caller is
+    // responsible for closing the returned file descriptor. On error, -1 will
+    // be returned and errno will indicate the problem.
+    int dup() const;
+
+private:
+    // Only allow instantiation using ref counting.
+    friend class LightRefBase<MiniFence>;
+    ~MiniFence();
+
+    int mFenceFd;
+
+};
+}
+#endif //EMU_HWC2_MINIFENCE_H
diff --git a/system/renderControl_enc/Android.mk b/system/renderControl_enc/Android.mk
index 5792440..fa90bcb 100644
--- a/system/renderControl_enc/Android.mk
+++ b/system/renderControl_enc/Android.mk
@@ -8,5 +8,5 @@
     renderControl_entry.cpp
 
 $(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
-$(call emugl-import,libOpenglCodecCommon)
+$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX))
 $(call emugl-end-module)
diff --git a/system/renderControl_enc/CMakeLists.txt b/system/renderControl_enc/CMakeLists.txt
new file mode 100644
index 0000000..40280fd
--- /dev/null
+++ b/system/renderControl_enc/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc/Android.mk" "f314acdb6134d3e545889739e6e9bf8837177ce2f3318106394c7656c5d8b992")
+set(_renderControl_enc_src renderControl_client_context.cpp renderControl_enc.cpp renderControl_entry.cpp)
+android_add_shared_library(_renderControl_enc)
+target_include_directories(_renderControl_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(_renderControl_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN")
+target_compile_options(_renderControl_enc PRIVATE "-fvisibility=default")
+target_link_libraries(_renderControl_enc PRIVATE OpenglCodecCommon_host cutils utils log android-emu-shared)
\ No newline at end of file
diff --git a/system/renderControl_enc/renderControl_client_context.cpp b/system/renderControl_enc/renderControl_client_context.cpp
index 4a86244..fb5ead1 100644
--- a/system/renderControl_enc/renderControl_client_context.cpp
+++ b/system/renderControl_enc/renderControl_client_context.cpp
@@ -47,6 +47,7 @@
 	rcUpdateColorBufferDMA = (rcUpdateColorBufferDMA_client_proc_t) getProc("rcUpdateColorBufferDMA", userData);
 	rcCreateColorBufferDMA = (rcCreateColorBufferDMA_client_proc_t) getProc("rcCreateColorBufferDMA", userData);
 	rcWaitSyncKHR = (rcWaitSyncKHR_client_proc_t) getProc("rcWaitSyncKHR", userData);
+	rcCompose = (rcCompose_client_proc_t) getProc("rcCompose", userData);
 	return 0;
 }
 
diff --git a/system/renderControl_enc/renderControl_client_context.h b/system/renderControl_enc/renderControl_client_context.h
index 1e5594b..5d3878c 100644
--- a/system/renderControl_enc/renderControl_client_context.h
+++ b/system/renderControl_enc/renderControl_client_context.h
@@ -47,6 +47,7 @@
 	rcUpdateColorBufferDMA_client_proc_t rcUpdateColorBufferDMA;
 	rcCreateColorBufferDMA_client_proc_t rcCreateColorBufferDMA;
 	rcWaitSyncKHR_client_proc_t rcWaitSyncKHR;
+	rcCompose_client_proc_t rcCompose;
 	virtual ~renderControl_client_context_t() {}
 
 	typedef renderControl_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
diff --git a/system/renderControl_enc/renderControl_client_proc.h b/system/renderControl_enc/renderControl_client_proc.h
index 3f1e5bb..24708dd 100644
--- a/system/renderControl_enc/renderControl_client_proc.h
+++ b/system/renderControl_enc/renderControl_client_proc.h
@@ -46,6 +46,7 @@
 typedef int (renderControl_APIENTRY *rcUpdateColorBufferDMA_client_proc_t) (void * ctx, uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*, uint32_t);
 typedef uint32_t (renderControl_APIENTRY *rcCreateColorBufferDMA_client_proc_t) (void * ctx, uint32_t, uint32_t, GLenum, int);
 typedef void (renderControl_APIENTRY *rcWaitSyncKHR_client_proc_t) (void * ctx, uint64_t, EGLint);
+typedef GLint (renderControl_APIENTRY *rcCompose_client_proc_t) (void * ctx, uint32_t, void*);
 
 
 #endif
diff --git a/system/renderControl_enc/renderControl_enc.cpp b/system/renderControl_enc/renderControl_enc.cpp
index e22d7c0..905b6a9 100644
--- a/system/renderControl_enc/renderControl_enc.cpp
+++ b/system/renderControl_enc/renderControl_enc.cpp
@@ -8,6 +8,8 @@
 #include "renderControl_enc.h"
 
 
+#include <vector>
+
 #include <stdio.h>
 
 namespace {
@@ -1391,6 +1393,49 @@
 
 }
 
+GLint rcCompose_enc(void *self , uint32_t bufferSize, void* buffer)
+{
+
+	renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
+	IOStream *stream = ctx->m_stream;
+	ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+	bool useChecksum = checksumCalculator->getVersion() > 0;
+
+	const unsigned int __size_buffer =  bufferSize;
+	 unsigned char *ptr;
+	 unsigned char *buf;
+	 const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 1*4;
+	 const size_t checksumSize = checksumCalculator->checksumByteSize();
+	 const size_t totalSize = sizeWithoutChecksum + checksumSize;
+	buf = stream->alloc(totalSize);
+	ptr = buf;
+	int tmp = OP_rcCompose;memcpy(ptr, &tmp, 4); ptr += 4;
+	memcpy(ptr, &totalSize, 4);  ptr += 4;
+
+		memcpy(ptr, &bufferSize, 4); ptr += 4;
+	*(unsigned int *)(ptr) = __size_buffer; ptr += 4;
+	memcpy(ptr, buffer, __size_buffer);ptr += __size_buffer;
+
+	if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+	if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+	GLint retval;
+	stream->readback(&retval, 4);
+	if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+	if (useChecksum) {
+		unsigned char *checksumBufPtr = NULL;
+		unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
+		if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
+		stream->readback(checksumBufPtr, checksumSize);
+		if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
+			ALOGE("rcCompose: GL communication error, please report this issue to b.android.com.\n");
+			abort();
+		}
+	}
+	return retval;
+}
+
 }  // namespace
 
 renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
@@ -1435,5 +1480,6 @@
 	this->rcUpdateColorBufferDMA = &rcUpdateColorBufferDMA_enc;
 	this->rcCreateColorBufferDMA = &rcCreateColorBufferDMA_enc;
 	this->rcWaitSyncKHR = &rcWaitSyncKHR_enc;
+	this->rcCompose = &rcCompose_enc;
 }
 
diff --git a/system/renderControl_enc/renderControl_entry.cpp b/system/renderControl_enc/renderControl_entry.cpp
index 9a47dd3..4296940 100644
--- a/system/renderControl_enc/renderControl_entry.cpp
+++ b/system/renderControl_enc/renderControl_entry.cpp
@@ -42,6 +42,7 @@
 	int rcUpdateColorBufferDMA(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels, uint32_t pixels_size);
 	uint32_t rcCreateColorBufferDMA(uint32_t width, uint32_t height, GLenum internalFormat, int frameworkFormat);
 	void rcWaitSyncKHR(uint64_t sync, EGLint flags);
+	GLint rcCompose(uint32_t bufferSize, void* buffer);
 };
 
 #ifndef GET_CONTEXT
@@ -272,3 +273,9 @@
 	ctx->rcWaitSyncKHR(ctx, sync, flags);
 }
 
+GLint rcCompose(uint32_t bufferSize, void* buffer)
+{
+	GET_CONTEXT;
+	return ctx->rcCompose(ctx, bufferSize, buffer);
+}
+
diff --git a/system/renderControl_enc/renderControl_ftable.h b/system/renderControl_enc/renderControl_ftable.h
index 7bfc7c5..ab75bb0 100644
--- a/system/renderControl_enc/renderControl_ftable.h
+++ b/system/renderControl_enc/renderControl_ftable.h
@@ -45,6 +45,7 @@
 	{"rcUpdateColorBufferDMA", (void*)rcUpdateColorBufferDMA},
 	{"rcCreateColorBufferDMA", (void*)rcCreateColorBufferDMA},
 	{"rcWaitSyncKHR", (void*)rcWaitSyncKHR},
+	{"rcCompose", (void*)rcCompose},
 };
 static const int renderControl_num_funcs = sizeof(renderControl_funcs_by_name) / sizeof(struct _renderControl_funcs_by_name);
 
diff --git a/system/renderControl_enc/renderControl_opcodes.h b/system/renderControl_enc/renderControl_opcodes.h
index 146164f..100faaa 100644
--- a/system/renderControl_enc/renderControl_opcodes.h
+++ b/system/renderControl_enc/renderControl_opcodes.h
@@ -40,7 +40,8 @@
 #define OP_rcUpdateColorBufferDMA 					10034
 #define OP_rcCreateColorBufferDMA 					10035
 #define OP_rcWaitSyncKHR 					10036
-#define OP_last 					10037
+#define OP_rcCompose 					10037
+#define OP_last 					10038
 
 
 #endif
diff --git a/system/vulkan/Android.mk b/system/vulkan/Android.mk
new file mode 100644
index 0000000..88118c2
--- /dev/null
+++ b/system/vulkan/Android.mk
@@ -0,0 +1,39 @@
+LOCAL_PATH := $(call my-dir)
+
+$(call emugl-begin-shared-library,vulkan.ranchu)
+$(call emugl-set-shared-library-subpath,hw)
+$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
+$(call emugl-import,libOpenglSystemCommon libvulkan_enc lib_renderControl_enc)
+$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX))
+
+# Vulkan include dir
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+LOCAL_C_INCLUDES += $(HOST_EMUGL_PATH)/host/include
+
+endif
+
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+# Only import androidemu if not building for host.
+# if building for host, we already import android-emu.
+$(call emugl-import,libandroidemu)
+
+LOCAL_HEADER_LIBRARIES += \
+    vulkan_headers \
+
+endif
+
+LOCAL_CFLAGS += \
+    -DLOG_TAG=\"goldfish_vulkan\" \
+    -Wno-missing-field-initializers \
+    -fvisibility=hidden \
+    -fstrict-aliasing \
+    -DVK_USE_PLATFORM_ANDROID_KHR \
+    -DVK_NO_PROTOTYPES \
+
+LOCAL_SRC_FILES := \
+    func_table.cpp \
+    goldfish_vulkan.cpp \
+
+$(call emugl-end-module)
diff --git a/system/vulkan/CMakeLists.txt b/system/vulkan/CMakeLists.txt
new file mode 100644
index 0000000..e7fd9bb
--- /dev/null
+++ b/system/vulkan/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan/Android.mk" "dbe5f184561a1505d6ed26216fe645508b64bf2f3800f67946428077045c8166")
+set(vulkan.ranchu_src func_table.cpp goldfish_vulkan.cpp)
+android_add_shared_library(vulkan.ranchu)
+target_include_directories(vulkan.ranchu PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/system/vulkan ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include)
+target_compile_definitions(vulkan.ranchu PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"goldfish_vulkan\"" "-DVK_USE_PLATFORM_ANDROID_KHR" "-DVK_NO_PROTOTYPES")
+target_compile_options(vulkan.ranchu PRIVATE "-fvisibility=default" "-Wno-missing-field-initializers" "-fvisibility=hidden" "-fstrict-aliasing")
+target_link_libraries(vulkan.ranchu PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/vulkan/func_table.cpp b/system/vulkan/func_table.cpp
new file mode 100644
index 0000000..ea87560
--- /dev/null
+++ b/system/vulkan/func_table.cpp
@@ -0,0 +1,4721 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module func_table
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "func_table.h"
+
+
+#include "VkEncoder.h"
+#include "HostConnection.h"
+
+#include "goldfish_vk_private_defs.h"
+
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+static VkResult entry_vkCreateInstance(
+    const VkInstanceCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkInstance* pInstance)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateInstance_VkResult_return = (VkResult)0;
+    vkCreateInstance_VkResult_return = vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance);
+    return vkCreateInstance_VkResult_return;
+}
+static void entry_vkDestroyInstance(
+    VkInstance instance,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyInstance(instance, pAllocator);
+}
+static VkResult entry_vkEnumeratePhysicalDevices(
+    VkInstance instance,
+    uint32_t* pPhysicalDeviceCount,
+    VkPhysicalDevice* pPhysicalDevices)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
+    vkEnumeratePhysicalDevices_VkResult_return = vkEnc->vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+    return vkEnumeratePhysicalDevices_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceFeatures(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceFeatures* pFeatures)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+}
+static void entry_vkGetPhysicalDeviceFormatProperties(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkFormatProperties* pFormatProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+}
+static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkImageType type,
+    VkImageTiling tiling,
+    VkImageUsageFlags usage,
+    VkImageCreateFlags flags,
+    VkImageFormatProperties* pImageFormatProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceImageFormatProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+    return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceProperties(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceProperties* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
+}
+static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+static void entry_vkGetPhysicalDeviceMemoryProperties(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+}
+static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(
+    VkInstance instance,
+    const char* pName)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+    vkGetInstanceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetInstanceProcAddr(instance, pName);
+    return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
+}
+static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(
+    VkDevice device,
+    const char* pName)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+    vkGetDeviceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetDeviceProcAddr(device, pName);
+    return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
+}
+static VkResult entry_vkCreateDevice(
+    VkPhysicalDevice physicalDevice,
+    const VkDeviceCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDevice* pDevice)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDevice_VkResult_return = (VkResult)0;
+    vkCreateDevice_VkResult_return = vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+    return vkCreateDevice_VkResult_return;
+}
+static void entry_vkDestroyDevice(
+    VkDevice device,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyDevice(device, pAllocator);
+}
+static VkResult entry_vkEnumerateInstanceExtensionProperties(
+    const char* pLayerName,
+    uint32_t* pPropertyCount,
+    VkExtensionProperties* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
+    vkEnumerateInstanceExtensionProperties_VkResult_return = vkEnc->vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
+    return vkEnumerateInstanceExtensionProperties_VkResult_return;
+}
+static VkResult entry_vkEnumerateDeviceExtensionProperties(
+    VkPhysicalDevice physicalDevice,
+    const char* pLayerName,
+    uint32_t* pPropertyCount,
+    VkExtensionProperties* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
+    vkEnumerateDeviceExtensionProperties_VkResult_return = vkEnc->vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
+    return vkEnumerateDeviceExtensionProperties_VkResult_return;
+}
+static VkResult entry_vkEnumerateInstanceLayerProperties(
+    uint32_t* pPropertyCount,
+    VkLayerProperties* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
+    vkEnumerateInstanceLayerProperties_VkResult_return = vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
+    return vkEnumerateInstanceLayerProperties_VkResult_return;
+}
+static VkResult entry_vkEnumerateDeviceLayerProperties(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pPropertyCount,
+    VkLayerProperties* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
+    vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
+    return vkEnumerateDeviceLayerProperties_VkResult_return;
+}
+static void entry_vkGetDeviceQueue(
+    VkDevice device,
+    uint32_t queueFamilyIndex,
+    uint32_t queueIndex,
+    VkQueue* pQueue)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+}
+static VkResult entry_vkQueueSubmit(
+    VkQueue queue,
+    uint32_t submitCount,
+    const VkSubmitInfo* pSubmits,
+    VkFence fence)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
+    vkQueueSubmit_VkResult_return = vkEnc->vkQueueSubmit(queue, submitCount, pSubmits, fence);
+    return vkQueueSubmit_VkResult_return;
+}
+static VkResult entry_vkQueueWaitIdle(
+    VkQueue queue)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
+    vkQueueWaitIdle_VkResult_return = vkEnc->vkQueueWaitIdle(queue);
+    return vkQueueWaitIdle_VkResult_return;
+}
+static VkResult entry_vkDeviceWaitIdle(
+    VkDevice device)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
+    vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device);
+    return vkDeviceWaitIdle_VkResult_return;
+}
+static VkResult entry_vkAllocateMemory(
+    VkDevice device,
+    const VkMemoryAllocateInfo* pAllocateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDeviceMemory* pMemory)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
+    vkAllocateMemory_VkResult_return = vkEnc->vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+    return vkAllocateMemory_VkResult_return;
+}
+static void entry_vkFreeMemory(
+    VkDevice device,
+    VkDeviceMemory memory,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkFreeMemory(device, memory, pAllocator);
+}
+static VkResult entry_vkMapMemory(
+    VkDevice device,
+    VkDeviceMemory memory,
+    VkDeviceSize offset,
+    VkDeviceSize size,
+    VkMemoryMapFlags flags,
+    void** ppData)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkMapMemory_VkResult_return = (VkResult)0;
+    vkMapMemory_VkResult_return = vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData);
+    return vkMapMemory_VkResult_return;
+}
+static void entry_vkUnmapMemory(
+    VkDevice device,
+    VkDeviceMemory memory)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkUnmapMemory(device, memory);
+}
+static VkResult entry_vkFlushMappedMemoryRanges(
+    VkDevice device,
+    uint32_t memoryRangeCount,
+    const VkMappedMemoryRange* pMemoryRanges)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
+    vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+    return vkFlushMappedMemoryRanges_VkResult_return;
+}
+static VkResult entry_vkInvalidateMappedMemoryRanges(
+    VkDevice device,
+    uint32_t memoryRangeCount,
+    const VkMappedMemoryRange* pMemoryRanges)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
+    vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+    return vkInvalidateMappedMemoryRanges_VkResult_return;
+}
+static void entry_vkGetDeviceMemoryCommitment(
+    VkDevice device,
+    VkDeviceMemory memory,
+    VkDeviceSize* pCommittedMemoryInBytes)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+}
+static VkResult entry_vkBindBufferMemory(
+    VkDevice device,
+    VkBuffer buffer,
+    VkDeviceMemory memory,
+    VkDeviceSize memoryOffset)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
+    vkBindBufferMemory_VkResult_return = vkEnc->vkBindBufferMemory(device, buffer, memory, memoryOffset);
+    return vkBindBufferMemory_VkResult_return;
+}
+static VkResult entry_vkBindImageMemory(
+    VkDevice device,
+    VkImage image,
+    VkDeviceMemory memory,
+    VkDeviceSize memoryOffset)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
+    vkBindImageMemory_VkResult_return = vkEnc->vkBindImageMemory(device, image, memory, memoryOffset);
+    return vkBindImageMemory_VkResult_return;
+}
+static void entry_vkGetBufferMemoryRequirements(
+    VkDevice device,
+    VkBuffer buffer,
+    VkMemoryRequirements* pMemoryRequirements)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+}
+static void entry_vkGetImageMemoryRequirements(
+    VkDevice device,
+    VkImage image,
+    VkMemoryRequirements* pMemoryRequirements)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
+}
+static void entry_vkGetImageSparseMemoryRequirements(
+    VkDevice device,
+    VkImage image,
+    uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+static void entry_vkGetPhysicalDeviceSparseImageFormatProperties(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkImageType type,
+    VkSampleCountFlagBits samples,
+    VkImageUsageFlags usage,
+    VkImageTiling tiling,
+    uint32_t* pPropertyCount,
+    VkSparseImageFormatProperties* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+}
+static VkResult entry_vkQueueBindSparse(
+    VkQueue queue,
+    uint32_t bindInfoCount,
+    const VkBindSparseInfo* pBindInfo,
+    VkFence fence)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
+    vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+    return vkQueueBindSparse_VkResult_return;
+}
+static VkResult entry_vkCreateFence(
+    VkDevice device,
+    const VkFenceCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkFence* pFence)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateFence_VkResult_return = (VkResult)0;
+    vkCreateFence_VkResult_return = vkEnc->vkCreateFence(device, pCreateInfo, pAllocator, pFence);
+    return vkCreateFence_VkResult_return;
+}
+static void entry_vkDestroyFence(
+    VkDevice device,
+    VkFence fence,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyFence(device, fence, pAllocator);
+}
+static VkResult entry_vkResetFences(
+    VkDevice device,
+    uint32_t fenceCount,
+    const VkFence* pFences)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkResetFences_VkResult_return = (VkResult)0;
+    vkResetFences_VkResult_return = vkEnc->vkResetFences(device, fenceCount, pFences);
+    return vkResetFences_VkResult_return;
+}
+static VkResult entry_vkGetFenceStatus(
+    VkDevice device,
+    VkFence fence)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
+    vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence);
+    return vkGetFenceStatus_VkResult_return;
+}
+static VkResult entry_vkWaitForFences(
+    VkDevice device,
+    uint32_t fenceCount,
+    const VkFence* pFences,
+    VkBool32 waitAll,
+    uint64_t timeout)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkWaitForFences_VkResult_return = (VkResult)0;
+    vkWaitForFences_VkResult_return = vkEnc->vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
+    return vkWaitForFences_VkResult_return;
+}
+static VkResult entry_vkCreateSemaphore(
+    VkDevice device,
+    const VkSemaphoreCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSemaphore* pSemaphore)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
+    vkCreateSemaphore_VkResult_return = vkEnc->vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+    return vkCreateSemaphore_VkResult_return;
+}
+static void entry_vkDestroySemaphore(
+    VkDevice device,
+    VkSemaphore semaphore,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroySemaphore(device, semaphore, pAllocator);
+}
+static VkResult entry_vkCreateEvent(
+    VkDevice device,
+    const VkEventCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkEvent* pEvent)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateEvent_VkResult_return = (VkResult)0;
+    vkCreateEvent_VkResult_return = vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
+    return vkCreateEvent_VkResult_return;
+}
+static void entry_vkDestroyEvent(
+    VkDevice device,
+    VkEvent event,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyEvent(device, event, pAllocator);
+}
+static VkResult entry_vkGetEventStatus(
+    VkDevice device,
+    VkEvent event)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
+    vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event);
+    return vkGetEventStatus_VkResult_return;
+}
+static VkResult entry_vkSetEvent(
+    VkDevice device,
+    VkEvent event)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkSetEvent_VkResult_return = (VkResult)0;
+    vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event);
+    return vkSetEvent_VkResult_return;
+}
+static VkResult entry_vkResetEvent(
+    VkDevice device,
+    VkEvent event)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkResetEvent_VkResult_return = (VkResult)0;
+    vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event);
+    return vkResetEvent_VkResult_return;
+}
+static VkResult entry_vkCreateQueryPool(
+    VkDevice device,
+    const VkQueryPoolCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkQueryPool* pQueryPool)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
+    vkCreateQueryPool_VkResult_return = vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+    return vkCreateQueryPool_VkResult_return;
+}
+static void entry_vkDestroyQueryPool(
+    VkDevice device,
+    VkQueryPool queryPool,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator);
+}
+static VkResult entry_vkGetQueryPoolResults(
+    VkDevice device,
+    VkQueryPool queryPool,
+    uint32_t firstQuery,
+    uint32_t queryCount,
+    size_t dataSize,
+    void* pData,
+    VkDeviceSize stride,
+    VkQueryResultFlags flags)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
+    vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+    return vkGetQueryPoolResults_VkResult_return;
+}
+static VkResult entry_vkCreateBuffer(
+    VkDevice device,
+    const VkBufferCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkBuffer* pBuffer)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
+    vkCreateBuffer_VkResult_return = vkEnc->vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+    return vkCreateBuffer_VkResult_return;
+}
+static void entry_vkDestroyBuffer(
+    VkDevice device,
+    VkBuffer buffer,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyBuffer(device, buffer, pAllocator);
+}
+static VkResult entry_vkCreateBufferView(
+    VkDevice device,
+    const VkBufferViewCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkBufferView* pView)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
+    vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
+    return vkCreateBufferView_VkResult_return;
+}
+static void entry_vkDestroyBufferView(
+    VkDevice device,
+    VkBufferView bufferView,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyBufferView(device, bufferView, pAllocator);
+}
+static VkResult entry_vkCreateImage(
+    VkDevice device,
+    const VkImageCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkImage* pImage)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateImage_VkResult_return = (VkResult)0;
+    vkCreateImage_VkResult_return = vkEnc->vkCreateImage(device, pCreateInfo, pAllocator, pImage);
+    return vkCreateImage_VkResult_return;
+}
+static void entry_vkDestroyImage(
+    VkDevice device,
+    VkImage image,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyImage(device, image, pAllocator);
+}
+static void entry_vkGetImageSubresourceLayout(
+    VkDevice device,
+    VkImage image,
+    const VkImageSubresource* pSubresource,
+    VkSubresourceLayout* pLayout)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
+}
+static VkResult entry_vkCreateImageView(
+    VkDevice device,
+    const VkImageViewCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkImageView* pView)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateImageView_VkResult_return = (VkResult)0;
+    vkCreateImageView_VkResult_return = vkEnc->vkCreateImageView(device, pCreateInfo, pAllocator, pView);
+    return vkCreateImageView_VkResult_return;
+}
+static void entry_vkDestroyImageView(
+    VkDevice device,
+    VkImageView imageView,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyImageView(device, imageView, pAllocator);
+}
+static VkResult entry_vkCreateShaderModule(
+    VkDevice device,
+    const VkShaderModuleCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkShaderModule* pShaderModule)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
+    vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+    return vkCreateShaderModule_VkResult_return;
+}
+static void entry_vkDestroyShaderModule(
+    VkDevice device,
+    VkShaderModule shaderModule,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator);
+}
+static VkResult entry_vkCreatePipelineCache(
+    VkDevice device,
+    const VkPipelineCacheCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkPipelineCache* pPipelineCache)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
+    vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+    return vkCreatePipelineCache_VkResult_return;
+}
+static void entry_vkDestroyPipelineCache(
+    VkDevice device,
+    VkPipelineCache pipelineCache,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator);
+}
+static VkResult entry_vkGetPipelineCacheData(
+    VkDevice device,
+    VkPipelineCache pipelineCache,
+    size_t* pDataSize,
+    void* pData)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
+    vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+    return vkGetPipelineCacheData_VkResult_return;
+}
+static VkResult entry_vkMergePipelineCaches(
+    VkDevice device,
+    VkPipelineCache dstCache,
+    uint32_t srcCacheCount,
+    const VkPipelineCache* pSrcCaches)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
+    vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+    return vkMergePipelineCaches_VkResult_return;
+}
+static VkResult entry_vkCreateGraphicsPipelines(
+    VkDevice device,
+    VkPipelineCache pipelineCache,
+    uint32_t createInfoCount,
+    const VkGraphicsPipelineCreateInfo* pCreateInfos,
+    const VkAllocationCallbacks* pAllocator,
+    VkPipeline* pPipelines)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
+    vkCreateGraphicsPipelines_VkResult_return = vkEnc->vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    return vkCreateGraphicsPipelines_VkResult_return;
+}
+static VkResult entry_vkCreateComputePipelines(
+    VkDevice device,
+    VkPipelineCache pipelineCache,
+    uint32_t createInfoCount,
+    const VkComputePipelineCreateInfo* pCreateInfos,
+    const VkAllocationCallbacks* pAllocator,
+    VkPipeline* pPipelines)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
+    vkCreateComputePipelines_VkResult_return = vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    return vkCreateComputePipelines_VkResult_return;
+}
+static void entry_vkDestroyPipeline(
+    VkDevice device,
+    VkPipeline pipeline,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyPipeline(device, pipeline, pAllocator);
+}
+static VkResult entry_vkCreatePipelineLayout(
+    VkDevice device,
+    const VkPipelineLayoutCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkPipelineLayout* pPipelineLayout)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
+    vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+    return vkCreatePipelineLayout_VkResult_return;
+}
+static void entry_vkDestroyPipelineLayout(
+    VkDevice device,
+    VkPipelineLayout pipelineLayout,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
+}
+static VkResult entry_vkCreateSampler(
+    VkDevice device,
+    const VkSamplerCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSampler* pSampler)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateSampler_VkResult_return = (VkResult)0;
+    vkCreateSampler_VkResult_return = vkEnc->vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
+    return vkCreateSampler_VkResult_return;
+}
+static void entry_vkDestroySampler(
+    VkDevice device,
+    VkSampler sampler,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroySampler(device, sampler, pAllocator);
+}
+static VkResult entry_vkCreateDescriptorSetLayout(
+    VkDevice device,
+    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDescriptorSetLayout* pSetLayout)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
+    vkCreateDescriptorSetLayout_VkResult_return = vkEnc->vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+    return vkCreateDescriptorSetLayout_VkResult_return;
+}
+static void entry_vkDestroyDescriptorSetLayout(
+    VkDevice device,
+    VkDescriptorSetLayout descriptorSetLayout,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+}
+static VkResult entry_vkCreateDescriptorPool(
+    VkDevice device,
+    const VkDescriptorPoolCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDescriptorPool* pDescriptorPool)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
+    vkCreateDescriptorPool_VkResult_return = vkEnc->vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+    return vkCreateDescriptorPool_VkResult_return;
+}
+static void entry_vkDestroyDescriptorPool(
+    VkDevice device,
+    VkDescriptorPool descriptorPool,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
+}
+static VkResult entry_vkResetDescriptorPool(
+    VkDevice device,
+    VkDescriptorPool descriptorPool,
+    VkDescriptorPoolResetFlags flags)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
+    vkResetDescriptorPool_VkResult_return = vkEnc->vkResetDescriptorPool(device, descriptorPool, flags);
+    return vkResetDescriptorPool_VkResult_return;
+}
+static VkResult entry_vkAllocateDescriptorSets(
+    VkDevice device,
+    const VkDescriptorSetAllocateInfo* pAllocateInfo,
+    VkDescriptorSet* pDescriptorSets)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
+    vkAllocateDescriptorSets_VkResult_return = vkEnc->vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+    return vkAllocateDescriptorSets_VkResult_return;
+}
+static VkResult entry_vkFreeDescriptorSets(
+    VkDevice device,
+    VkDescriptorPool descriptorPool,
+    uint32_t descriptorSetCount,
+    const VkDescriptorSet* pDescriptorSets)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
+    vkFreeDescriptorSets_VkResult_return = vkEnc->vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+    return vkFreeDescriptorSets_VkResult_return;
+}
+static void entry_vkUpdateDescriptorSets(
+    VkDevice device,
+    uint32_t descriptorWriteCount,
+    const VkWriteDescriptorSet* pDescriptorWrites,
+    uint32_t descriptorCopyCount,
+    const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+}
+static VkResult entry_vkCreateFramebuffer(
+    VkDevice device,
+    const VkFramebufferCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkFramebuffer* pFramebuffer)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
+    vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+    return vkCreateFramebuffer_VkResult_return;
+}
+static void entry_vkDestroyFramebuffer(
+    VkDevice device,
+    VkFramebuffer framebuffer,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator);
+}
+static VkResult entry_vkCreateRenderPass(
+    VkDevice device,
+    const VkRenderPassCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkRenderPass* pRenderPass)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
+    vkCreateRenderPass_VkResult_return = vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+    return vkCreateRenderPass_VkResult_return;
+}
+static void entry_vkDestroyRenderPass(
+    VkDevice device,
+    VkRenderPass renderPass,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator);
+}
+static void entry_vkGetRenderAreaGranularity(
+    VkDevice device,
+    VkRenderPass renderPass,
+    VkExtent2D* pGranularity)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity);
+}
+static VkResult entry_vkCreateCommandPool(
+    VkDevice device,
+    const VkCommandPoolCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkCommandPool* pCommandPool)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
+    vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+    return vkCreateCommandPool_VkResult_return;
+}
+static void entry_vkDestroyCommandPool(
+    VkDevice device,
+    VkCommandPool commandPool,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator);
+}
+static VkResult entry_vkResetCommandPool(
+    VkDevice device,
+    VkCommandPool commandPool,
+    VkCommandPoolResetFlags flags)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
+    vkResetCommandPool_VkResult_return = vkEnc->vkResetCommandPool(device, commandPool, flags);
+    return vkResetCommandPool_VkResult_return;
+}
+static VkResult entry_vkAllocateCommandBuffers(
+    VkDevice device,
+    const VkCommandBufferAllocateInfo* pAllocateInfo,
+    VkCommandBuffer* pCommandBuffers)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
+    vkAllocateCommandBuffers_VkResult_return = vkEnc->vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
+    return vkAllocateCommandBuffers_VkResult_return;
+}
+static void entry_vkFreeCommandBuffers(
+    VkDevice device,
+    VkCommandPool commandPool,
+    uint32_t commandBufferCount,
+    const VkCommandBuffer* pCommandBuffers)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+}
+static VkResult entry_vkBeginCommandBuffer(
+    VkCommandBuffer commandBuffer,
+    const VkCommandBufferBeginInfo* pBeginInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
+    vkBeginCommandBuffer_VkResult_return = vkEnc->vkBeginCommandBuffer(commandBuffer, pBeginInfo);
+    return vkBeginCommandBuffer_VkResult_return;
+}
+static VkResult entry_vkEndCommandBuffer(
+    VkCommandBuffer commandBuffer)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
+    vkEndCommandBuffer_VkResult_return = vkEnc->vkEndCommandBuffer(commandBuffer);
+    return vkEndCommandBuffer_VkResult_return;
+}
+static VkResult entry_vkResetCommandBuffer(
+    VkCommandBuffer commandBuffer,
+    VkCommandBufferResetFlags flags)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
+    vkResetCommandBuffer_VkResult_return = vkEnc->vkResetCommandBuffer(commandBuffer, flags);
+    return vkResetCommandBuffer_VkResult_return;
+}
+static void entry_vkCmdBindPipeline(
+    VkCommandBuffer commandBuffer,
+    VkPipelineBindPoint pipelineBindPoint,
+    VkPipeline pipeline)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+}
+static void entry_vkCmdSetViewport(
+    VkCommandBuffer commandBuffer,
+    uint32_t firstViewport,
+    uint32_t viewportCount,
+    const VkViewport* pViewports)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
+}
+static void entry_vkCmdSetScissor(
+    VkCommandBuffer commandBuffer,
+    uint32_t firstScissor,
+    uint32_t scissorCount,
+    const VkRect2D* pScissors)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
+}
+static void entry_vkCmdSetLineWidth(
+    VkCommandBuffer commandBuffer,
+    float lineWidth)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth);
+}
+static void entry_vkCmdSetDepthBias(
+    VkCommandBuffer commandBuffer,
+    float depthBiasConstantFactor,
+    float depthBiasClamp,
+    float depthBiasSlopeFactor)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+}
+static void entry_vkCmdSetBlendConstants(
+    VkCommandBuffer commandBuffer,
+    const float blendConstants)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants);
+}
+static void entry_vkCmdSetDepthBounds(
+    VkCommandBuffer commandBuffer,
+    float minDepthBounds,
+    float maxDepthBounds)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+}
+static void entry_vkCmdSetStencilCompareMask(
+    VkCommandBuffer commandBuffer,
+    VkStencilFaceFlags faceMask,
+    uint32_t compareMask)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+}
+static void entry_vkCmdSetStencilWriteMask(
+    VkCommandBuffer commandBuffer,
+    VkStencilFaceFlags faceMask,
+    uint32_t writeMask)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+}
+static void entry_vkCmdSetStencilReference(
+    VkCommandBuffer commandBuffer,
+    VkStencilFaceFlags faceMask,
+    uint32_t reference)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference);
+}
+static void entry_vkCmdBindDescriptorSets(
+    VkCommandBuffer commandBuffer,
+    VkPipelineBindPoint pipelineBindPoint,
+    VkPipelineLayout layout,
+    uint32_t firstSet,
+    uint32_t descriptorSetCount,
+    const VkDescriptorSet* pDescriptorSets,
+    uint32_t dynamicOffsetCount,
+    const uint32_t* pDynamicOffsets)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+}
+static void entry_vkCmdBindIndexBuffer(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    VkIndexType indexType)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+}
+static void entry_vkCmdBindVertexBuffers(
+    VkCommandBuffer commandBuffer,
+    uint32_t firstBinding,
+    uint32_t bindingCount,
+    const VkBuffer* pBuffers,
+    const VkDeviceSize* pOffsets)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+}
+static void entry_vkCmdDraw(
+    VkCommandBuffer commandBuffer,
+    uint32_t vertexCount,
+    uint32_t instanceCount,
+    uint32_t firstVertex,
+    uint32_t firstInstance)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+}
+static void entry_vkCmdDrawIndexed(
+    VkCommandBuffer commandBuffer,
+    uint32_t indexCount,
+    uint32_t instanceCount,
+    uint32_t firstIndex,
+    int32_t vertexOffset,
+    uint32_t firstInstance)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+}
+static void entry_vkCmdDrawIndirect(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    uint32_t drawCount,
+    uint32_t stride)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+static void entry_vkCmdDrawIndexedIndirect(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    uint32_t drawCount,
+    uint32_t stride)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+static void entry_vkCmdDispatch(
+    VkCommandBuffer commandBuffer,
+    uint32_t groupCountX,
+    uint32_t groupCountY,
+    uint32_t groupCountZ)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
+}
+static void entry_vkCmdDispatchIndirect(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset);
+}
+static void entry_vkCmdCopyBuffer(
+    VkCommandBuffer commandBuffer,
+    VkBuffer srcBuffer,
+    VkBuffer dstBuffer,
+    uint32_t regionCount,
+    const VkBufferCopy* pRegions)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+}
+static void entry_vkCmdCopyImage(
+    VkCommandBuffer commandBuffer,
+    VkImage srcImage,
+    VkImageLayout srcImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
+    uint32_t regionCount,
+    const VkImageCopy* pRegions)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+static void entry_vkCmdBlitImage(
+    VkCommandBuffer commandBuffer,
+    VkImage srcImage,
+    VkImageLayout srcImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
+    uint32_t regionCount,
+    const VkImageBlit* pRegions,
+    VkFilter filter)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+}
+static void entry_vkCmdCopyBufferToImage(
+    VkCommandBuffer commandBuffer,
+    VkBuffer srcBuffer,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
+    uint32_t regionCount,
+    const VkBufferImageCopy* pRegions)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+}
+static void entry_vkCmdCopyImageToBuffer(
+    VkCommandBuffer commandBuffer,
+    VkImage srcImage,
+    VkImageLayout srcImageLayout,
+    VkBuffer dstBuffer,
+    uint32_t regionCount,
+    const VkBufferImageCopy* pRegions)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+}
+static void entry_vkCmdUpdateBuffer(
+    VkCommandBuffer commandBuffer,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
+    VkDeviceSize dataSize,
+    const void* pData)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+}
+static void entry_vkCmdFillBuffer(
+    VkCommandBuffer commandBuffer,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
+    VkDeviceSize size,
+    uint32_t data)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+}
+static void entry_vkCmdClearColorImage(
+    VkCommandBuffer commandBuffer,
+    VkImage image,
+    VkImageLayout imageLayout,
+    const VkClearColorValue* pColor,
+    uint32_t rangeCount,
+    const VkImageSubresourceRange* pRanges)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+}
+static void entry_vkCmdClearDepthStencilImage(
+    VkCommandBuffer commandBuffer,
+    VkImage image,
+    VkImageLayout imageLayout,
+    const VkClearDepthStencilValue* pDepthStencil,
+    uint32_t rangeCount,
+    const VkImageSubresourceRange* pRanges)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+}
+static void entry_vkCmdClearAttachments(
+    VkCommandBuffer commandBuffer,
+    uint32_t attachmentCount,
+    const VkClearAttachment* pAttachments,
+    uint32_t rectCount,
+    const VkClearRect* pRects)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+}
+static void entry_vkCmdResolveImage(
+    VkCommandBuffer commandBuffer,
+    VkImage srcImage,
+    VkImageLayout srcImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
+    uint32_t regionCount,
+    const VkImageResolve* pRegions)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+static void entry_vkCmdSetEvent(
+    VkCommandBuffer commandBuffer,
+    VkEvent event,
+    VkPipelineStageFlags stageMask)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask);
+}
+static void entry_vkCmdResetEvent(
+    VkCommandBuffer commandBuffer,
+    VkEvent event,
+    VkPipelineStageFlags stageMask)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask);
+}
+static void entry_vkCmdWaitEvents(
+    VkCommandBuffer commandBuffer,
+    uint32_t eventCount,
+    const VkEvent* pEvents,
+    VkPipelineStageFlags srcStageMask,
+    VkPipelineStageFlags dstStageMask,
+    uint32_t memoryBarrierCount,
+    const VkMemoryBarrier* pMemoryBarriers,
+    uint32_t bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+    uint32_t imageMemoryBarrierCount,
+    const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+static void entry_vkCmdPipelineBarrier(
+    VkCommandBuffer commandBuffer,
+    VkPipelineStageFlags srcStageMask,
+    VkPipelineStageFlags dstStageMask,
+    VkDependencyFlags dependencyFlags,
+    uint32_t memoryBarrierCount,
+    const VkMemoryBarrier* pMemoryBarriers,
+    uint32_t bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+    uint32_t imageMemoryBarrierCount,
+    const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+static void entry_vkCmdBeginQuery(
+    VkCommandBuffer commandBuffer,
+    VkQueryPool queryPool,
+    uint32_t query,
+    VkQueryControlFlags flags)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
+}
+static void entry_vkCmdEndQuery(
+    VkCommandBuffer commandBuffer,
+    VkQueryPool queryPool,
+    uint32_t query)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query);
+}
+static void entry_vkCmdResetQueryPool(
+    VkCommandBuffer commandBuffer,
+    VkQueryPool queryPool,
+    uint32_t firstQuery,
+    uint32_t queryCount)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
+}
+static void entry_vkCmdWriteTimestamp(
+    VkCommandBuffer commandBuffer,
+    VkPipelineStageFlagBits pipelineStage,
+    VkQueryPool queryPool,
+    uint32_t query)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
+}
+static void entry_vkCmdCopyQueryPoolResults(
+    VkCommandBuffer commandBuffer,
+    VkQueryPool queryPool,
+    uint32_t firstQuery,
+    uint32_t queryCount,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
+    VkDeviceSize stride,
+    VkQueryResultFlags flags)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+}
+static void entry_vkCmdPushConstants(
+    VkCommandBuffer commandBuffer,
+    VkPipelineLayout layout,
+    VkShaderStageFlags stageFlags,
+    uint32_t offset,
+    uint32_t size,
+    const void* pValues)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+}
+static void entry_vkCmdBeginRenderPass(
+    VkCommandBuffer commandBuffer,
+    const VkRenderPassBeginInfo* pRenderPassBegin,
+    VkSubpassContents contents)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+}
+static void entry_vkCmdNextSubpass(
+    VkCommandBuffer commandBuffer,
+    VkSubpassContents contents)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdNextSubpass(commandBuffer, contents);
+}
+static void entry_vkCmdEndRenderPass(
+    VkCommandBuffer commandBuffer)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdEndRenderPass(commandBuffer);
+}
+static void entry_vkCmdExecuteCommands(
+    VkCommandBuffer commandBuffer,
+    uint32_t commandBufferCount,
+    const VkCommandBuffer* pCommandBuffers)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
+}
+#endif
+#ifdef VK_VERSION_1_1
+static VkResult entry_vkEnumerateInstanceVersion(
+    uint32_t* pApiVersion)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
+    vkEnumerateInstanceVersion_VkResult_return = vkEnc->vkEnumerateInstanceVersion(pApiVersion);
+    return vkEnumerateInstanceVersion_VkResult_return;
+}
+static VkResult entry_vkBindBufferMemory2(
+    VkDevice device,
+    uint32_t bindInfoCount,
+    const VkBindBufferMemoryInfo* pBindInfos)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
+    vkBindBufferMemory2_VkResult_return = vkEnc->vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
+    return vkBindBufferMemory2_VkResult_return;
+}
+static VkResult entry_vkBindImageMemory2(
+    VkDevice device,
+    uint32_t bindInfoCount,
+    const VkBindImageMemoryInfo* pBindInfos)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
+    vkBindImageMemory2_VkResult_return = vkEnc->vkBindImageMemory2(device, bindInfoCount, pBindInfos);
+    return vkBindImageMemory2_VkResult_return;
+}
+static void entry_vkGetDeviceGroupPeerMemoryFeatures(
+    VkDevice device,
+    uint32_t heapIndex,
+    uint32_t localDeviceIndex,
+    uint32_t remoteDeviceIndex,
+    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+}
+static void entry_vkCmdSetDeviceMask(
+    VkCommandBuffer commandBuffer,
+    uint32_t deviceMask)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask);
+}
+static void entry_vkCmdDispatchBase(
+    VkCommandBuffer commandBuffer,
+    uint32_t baseGroupX,
+    uint32_t baseGroupY,
+    uint32_t baseGroupZ,
+    uint32_t groupCountX,
+    uint32_t groupCountY,
+    uint32_t groupCountZ)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+}
+static VkResult entry_vkEnumeratePhysicalDeviceGroups(
+    VkInstance instance,
+    uint32_t* pPhysicalDeviceGroupCount,
+    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
+    vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+    return vkEnumeratePhysicalDeviceGroups_VkResult_return;
+}
+static void entry_vkGetImageMemoryRequirements2(
+    VkDevice device,
+    const VkImageMemoryRequirementsInfo2* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetBufferMemoryRequirements2(
+    VkDevice device,
+    const VkBufferMemoryRequirementsInfo2* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetImageSparseMemoryRequirements2(
+    VkDevice device,
+    const VkImageSparseMemoryRequirementsInfo2* pInfo,
+    uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+static void entry_vkGetPhysicalDeviceFeatures2(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceFeatures2* pFeatures)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
+}
+static void entry_vkGetPhysicalDeviceProperties2(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceProperties2* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
+}
+static void entry_vkGetPhysicalDeviceFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkFormatProperties2* pFormatProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
+}
+static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+    VkImageFormatProperties2* pImageFormatProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
+    return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceQueueFamilyProperties2(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+static void entry_vkGetPhysicalDeviceMemoryProperties2(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
+}
+static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+    uint32_t* pPropertyCount,
+    VkSparseImageFormatProperties2* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+}
+static void entry_vkTrimCommandPool(
+    VkDevice device,
+    VkCommandPool commandPool,
+    VkCommandPoolTrimFlags flags)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkTrimCommandPool(device, commandPool, flags);
+}
+static void entry_vkGetDeviceQueue2(
+    VkDevice device,
+    const VkDeviceQueueInfo2* pQueueInfo,
+    VkQueue* pQueue)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue);
+}
+static VkResult entry_vkCreateSamplerYcbcrConversion(
+    VkDevice device,
+    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
+    vkCreateSamplerYcbcrConversion_VkResult_return = vkEnc->vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
+    return vkCreateSamplerYcbcrConversion_VkResult_return;
+}
+static void entry_vkDestroySamplerYcbcrConversion(
+    VkDevice device,
+    VkSamplerYcbcrConversion ycbcrConversion,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
+}
+static VkResult entry_vkCreateDescriptorUpdateTemplate(
+    VkDevice device,
+    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
+    vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    return vkCreateDescriptorUpdateTemplate_VkResult_return;
+}
+static void entry_vkDestroyDescriptorUpdateTemplate(
+    VkDevice device,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
+}
+static void entry_vkUpdateDescriptorSetWithTemplate(
+    VkDevice device,
+    VkDescriptorSet descriptorSet,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+    const void* pData)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
+}
+static void entry_vkGetPhysicalDeviceExternalBufferProperties(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+    VkExternalBufferProperties* pExternalBufferProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+}
+static void entry_vkGetPhysicalDeviceExternalFenceProperties(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+    VkExternalFenceProperties* pExternalFenceProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+}
+static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+}
+static void entry_vkGetDescriptorSetLayoutSupport(
+    VkDevice device,
+    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    VkDescriptorSetLayoutSupport* pSupport)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+}
+#endif
+#ifdef VK_KHR_surface
+static void entry_vkDestroySurfaceKHR(
+    VkInstance instance,
+    VkSurfaceKHR surface,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroySurfaceKHR(instance, surface, pAllocator);
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex,
+    VkSurfaceKHR surface,
+    VkBool32* pSupported)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
+    return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+    VkPhysicalDevice physicalDevice,
+    VkSurfaceKHR surface,
+    VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
+    return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceFormatsKHR(
+    VkPhysicalDevice physicalDevice,
+    VkSurfaceKHR surface,
+    uint32_t* pSurfaceFormatCount,
+    VkSurfaceFormatKHR* pSurfaceFormats)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+    return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfacePresentModesKHR(
+    VkPhysicalDevice physicalDevice,
+    VkSurfaceKHR surface,
+    uint32_t* pPresentModeCount,
+    VkPresentModeKHR* pPresentModes)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+    return vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_swapchain
+static VkResult entry_vkCreateSwapchainKHR(
+    VkDevice device,
+    const VkSwapchainCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSwapchainKHR* pSwapchain)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
+    vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+    return vkCreateSwapchainKHR_VkResult_return;
+}
+static void entry_vkDestroySwapchainKHR(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator);
+}
+static VkResult entry_vkGetSwapchainImagesKHR(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    uint32_t* pSwapchainImageCount,
+    VkImage* pSwapchainImages)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
+    vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+    return vkGetSwapchainImagesKHR_VkResult_return;
+}
+static VkResult entry_vkAcquireNextImageKHR(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    uint64_t timeout,
+    VkSemaphore semaphore,
+    VkFence fence,
+    uint32_t* pImageIndex)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
+    vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+    return vkAcquireNextImageKHR_VkResult_return;
+}
+static VkResult entry_vkQueuePresentKHR(
+    VkQueue queue,
+    const VkPresentInfoKHR* pPresentInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
+    vkQueuePresentKHR_VkResult_return = vkEnc->vkQueuePresentKHR(queue, pPresentInfo);
+    return vkQueuePresentKHR_VkResult_return;
+}
+static VkResult entry_vkGetDeviceGroupPresentCapabilitiesKHR(
+    VkDevice device,
+    VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
+    vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
+    return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetDeviceGroupSurfacePresentModesKHR(
+    VkDevice device,
+    VkSurfaceKHR surface,
+    VkDeviceGroupPresentModeFlagsKHR* pModes)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+    vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
+    return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDevicePresentRectanglesKHR(
+    VkPhysicalDevice physicalDevice,
+    VkSurfaceKHR surface,
+    uint32_t* pRectCount,
+    VkRect2D* pRects)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = vkEnc->vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
+    return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
+}
+static VkResult entry_vkAcquireNextImage2KHR(
+    VkDevice device,
+    const VkAcquireNextImageInfoKHR* pAcquireInfo,
+    uint32_t* pImageIndex)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
+    vkAcquireNextImage2KHR_VkResult_return = vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
+    return vkAcquireNextImage2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display
+static VkResult entry_vkGetPhysicalDeviceDisplayPropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pPropertyCount,
+    VkDisplayPropertiesKHR* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
+    return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pPropertyCount,
+    VkDisplayPlanePropertiesKHR* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
+    return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayPlaneSupportedDisplaysKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t planeIndex,
+    uint32_t* pDisplayCount,
+    VkDisplayKHR* pDisplays)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
+    vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = vkEnc->vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
+    return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayModePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    VkDisplayKHR display,
+    uint32_t* pPropertyCount,
+    VkDisplayModePropertiesKHR* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
+    vkGetDisplayModePropertiesKHR_VkResult_return = vkEnc->vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
+    return vkGetDisplayModePropertiesKHR_VkResult_return;
+}
+static VkResult entry_vkCreateDisplayModeKHR(
+    VkPhysicalDevice physicalDevice,
+    VkDisplayKHR display,
+    const VkDisplayModeCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDisplayModeKHR* pMode)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
+    vkCreateDisplayModeKHR_VkResult_return = vkEnc->vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
+    return vkCreateDisplayModeKHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayPlaneCapabilitiesKHR(
+    VkPhysicalDevice physicalDevice,
+    VkDisplayModeKHR mode,
+    uint32_t planeIndex,
+    VkDisplayPlaneCapabilitiesKHR* pCapabilities)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
+    vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
+    return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
+}
+static VkResult entry_vkCreateDisplayPlaneSurfaceKHR(
+    VkInstance instance,
+    const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
+    vkCreateDisplayPlaneSurfaceKHR_VkResult_return = vkEnc->vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+    return vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display_swapchain
+static VkResult entry_vkCreateSharedSwapchainsKHR(
+    VkDevice device,
+    uint32_t swapchainCount,
+    const VkSwapchainCreateInfoKHR* pCreateInfos,
+    const VkAllocationCallbacks* pAllocator,
+    VkSwapchainKHR* pSwapchains)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
+    vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
+    return vkCreateSharedSwapchainsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_xlib_surface
+static VkResult entry_vkCreateXlibSurfaceKHR(
+    VkInstance instance,
+    const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
+    vkCreateXlibSurfaceKHR_VkResult_return = vkEnc->vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+    return vkCreateXlibSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex,
+    Display* dpy,
+    VisualID visualID)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
+    return vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_xcb_surface
+static VkResult entry_vkCreateXcbSurfaceKHR(
+    VkInstance instance,
+    const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
+    vkCreateXcbSurfaceKHR_VkResult_return = vkEnc->vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+    return vkCreateXcbSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceXcbPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex,
+    xcb_connection_t* connection,
+    xcb_visualid_t visual_id)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
+    return vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_wayland_surface
+static VkResult entry_vkCreateWaylandSurfaceKHR(
+    VkInstance instance,
+    const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
+    vkCreateWaylandSurfaceKHR_VkResult_return = vkEnc->vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+    return vkCreateWaylandSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex,
+    wl_display* display)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
+    return vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_mir_surface
+static VkResult entry_vkCreateMirSurfaceKHR(
+    VkInstance instance,
+    const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
+    vkCreateMirSurfaceKHR_VkResult_return = vkEnc->vkCreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+    return vkCreateMirSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceMirPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex,
+    MirConnection* connection)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceMirPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection);
+    return vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_android_surface
+static VkResult entry_vkCreateAndroidSurfaceKHR(
+    VkInstance instance,
+    const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
+    vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+    return vkCreateAndroidSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_surface
+static VkResult entry_vkCreateWin32SurfaceKHR(
+    VkInstance instance,
+    const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
+    vkCreateWin32SurfaceKHR_VkResult_return = vkEnc->vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+    return vkCreateWin32SurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceWin32PresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
+    return vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+static void entry_vkGetPhysicalDeviceFeatures2KHR(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceFeatures2* pFeatures)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
+}
+static void entry_vkGetPhysicalDeviceProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceProperties2* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
+}
+static void entry_vkGetPhysicalDeviceFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkFormatProperties2* pFormatProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
+}
+static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+    VkImageFormatProperties2* pImageFormatProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
+    return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+static void entry_vkGetPhysicalDeviceMemoryProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
+}
+static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+    uint32_t* pPropertyCount,
+    VkSparseImageFormatProperties2* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+}
+#endif
+#ifdef VK_KHR_device_group
+static void entry_vkGetDeviceGroupPeerMemoryFeaturesKHR(
+    VkDevice device,
+    uint32_t heapIndex,
+    uint32_t localDeviceIndex,
+    uint32_t remoteDeviceIndex,
+    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+}
+static void entry_vkCmdSetDeviceMaskKHR(
+    VkCommandBuffer commandBuffer,
+    uint32_t deviceMask)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask);
+}
+static void entry_vkCmdDispatchBaseKHR(
+    VkCommandBuffer commandBuffer,
+    uint32_t baseGroupX,
+    uint32_t baseGroupY,
+    uint32_t baseGroupZ,
+    uint32_t groupCountX,
+    uint32_t groupCountY,
+    uint32_t groupCountZ)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+}
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+static void entry_vkTrimCommandPoolKHR(
+    VkDevice device,
+    VkCommandPool commandPool,
+    VkCommandPoolTrimFlags flags)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags);
+}
+#endif
+#ifdef VK_KHR_device_group_creation
+static VkResult entry_vkEnumeratePhysicalDeviceGroupsKHR(
+    VkInstance instance,
+    uint32_t* pPhysicalDeviceGroupCount,
+    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
+    vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+    return vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+static void entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+    VkExternalBufferProperties* pExternalBufferProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+}
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+static VkResult entry_vkGetMemoryWin32HandleKHR(
+    VkDevice device,
+    const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+    HANDLE* pHandle)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
+    vkGetMemoryWin32HandleKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+    return vkGetMemoryWin32HandleKHR_VkResult_return;
+}
+static VkResult entry_vkGetMemoryWin32HandlePropertiesKHR(
+    VkDevice device,
+    VkExternalMemoryHandleTypeFlagBits handleType,
+    HANDLE handle,
+    VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
+    vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
+    return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_fd
+static VkResult entry_vkGetMemoryFdKHR(
+    VkDevice device,
+    const VkMemoryGetFdInfoKHR* pGetFdInfo,
+    int* pFd)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
+    vkGetMemoryFdKHR_VkResult_return = vkEnc->vkGetMemoryFdKHR(device, pGetFdInfo, pFd);
+    return vkGetMemoryFdKHR_VkResult_return;
+}
+static VkResult entry_vkGetMemoryFdPropertiesKHR(
+    VkDevice device,
+    VkExternalMemoryHandleTypeFlagBits handleType,
+    int fd,
+    VkMemoryFdPropertiesKHR* pMemoryFdProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
+    vkGetMemoryFdPropertiesKHR_VkResult_return = vkEnc->vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
+    return vkGetMemoryFdPropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+static void entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+}
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+static VkResult entry_vkImportSemaphoreWin32HandleKHR(
+    VkDevice device,
+    const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+    vkImportSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
+    return vkImportSemaphoreWin32HandleKHR_VkResult_return;
+}
+static VkResult entry_vkGetSemaphoreWin32HandleKHR(
+    VkDevice device,
+    const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+    HANDLE* pHandle)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+    vkGetSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+    return vkGetSemaphoreWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+static VkResult entry_vkImportSemaphoreFdKHR(
+    VkDevice device,
+    const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
+    vkImportSemaphoreFdKHR_VkResult_return = vkEnc->vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
+    return vkImportSemaphoreFdKHR_VkResult_return;
+}
+static VkResult entry_vkGetSemaphoreFdKHR(
+    VkDevice device,
+    const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+    int* pFd)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
+    vkGetSemaphoreFdKHR_VkResult_return = vkEnc->vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd);
+    return vkGetSemaphoreFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_push_descriptor
+static void entry_vkCmdPushDescriptorSetKHR(
+    VkCommandBuffer commandBuffer,
+    VkPipelineBindPoint pipelineBindPoint,
+    VkPipelineLayout layout,
+    uint32_t set,
+    uint32_t descriptorWriteCount,
+    const VkWriteDescriptorSet* pDescriptorWrites)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
+}
+static void entry_vkCmdPushDescriptorSetWithTemplateKHR(
+    VkCommandBuffer commandBuffer,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+    VkPipelineLayout layout,
+    uint32_t set,
+    const void* pData)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
+}
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+static VkResult entry_vkCreateDescriptorUpdateTemplateKHR(
+    VkDevice device,
+    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+    vkCreateDescriptorUpdateTemplateKHR_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
+}
+static void entry_vkDestroyDescriptorUpdateTemplateKHR(
+    VkDevice device,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
+}
+static void entry_vkUpdateDescriptorSetWithTemplateKHR(
+    VkDevice device,
+    VkDescriptorSet descriptorSet,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+    const void* pData)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
+}
+#endif
+#ifdef VK_KHR_create_renderpass2
+static VkResult entry_vkCreateRenderPass2KHR(
+    VkDevice device,
+    const VkRenderPassCreateInfo2KHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkRenderPass* pRenderPass)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
+    vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
+    return vkCreateRenderPass2KHR_VkResult_return;
+}
+static void entry_vkCmdBeginRenderPass2KHR(
+    VkCommandBuffer commandBuffer,
+    const VkRenderPassBeginInfo* pRenderPassBegin,
+    const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+}
+static void entry_vkCmdNextSubpass2KHR(
+    VkCommandBuffer commandBuffer,
+    const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+    const VkSubpassEndInfoKHR* pSubpassEndInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+}
+static void entry_vkCmdEndRenderPass2KHR(
+    VkCommandBuffer commandBuffer,
+    const VkSubpassEndInfoKHR* pSubpassEndInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
+}
+#endif
+#ifdef VK_KHR_shared_presentable_image
+static VkResult entry_vkGetSwapchainStatusKHR(
+    VkDevice device,
+    VkSwapchainKHR swapchain)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
+    vkGetSwapchainStatusKHR_VkResult_return = vkEnc->vkGetSwapchainStatusKHR(device, swapchain);
+    return vkGetSwapchainStatusKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+static void entry_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+    VkExternalFenceProperties* pExternalFenceProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+}
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+static VkResult entry_vkImportFenceWin32HandleKHR(
+    VkDevice device,
+    const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+    vkImportFenceWin32HandleKHR_VkResult_return = vkEnc->vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
+    return vkImportFenceWin32HandleKHR_VkResult_return;
+}
+static VkResult entry_vkGetFenceWin32HandleKHR(
+    VkDevice device,
+    const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+    HANDLE* pHandle)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+    vkGetFenceWin32HandleKHR_VkResult_return = vkEnc->vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+    return vkGetFenceWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_fd
+static VkResult entry_vkImportFenceFdKHR(
+    VkDevice device,
+    const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
+    vkImportFenceFdKHR_VkResult_return = vkEnc->vkImportFenceFdKHR(device, pImportFenceFdInfo);
+    return vkImportFenceFdKHR_VkResult_return;
+}
+static VkResult entry_vkGetFenceFdKHR(
+    VkDevice device,
+    const VkFenceGetFdInfoKHR* pGetFdInfo,
+    int* pFd)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
+    vkGetFenceFdKHR_VkResult_return = vkEnc->vkGetFenceFdKHR(device, pGetFdInfo, pFd);
+    return vkGetFenceFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+    VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
+    return vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceFormats2KHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+    uint32_t* pSurfaceFormatCount,
+    VkSurfaceFormat2KHR* pSurfaceFormats)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
+    return vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+static VkResult entry_vkGetPhysicalDeviceDisplayProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pPropertyCount,
+    VkDisplayProperties2KHR* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
+    return vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pPropertyCount,
+    VkDisplayPlaneProperties2KHR* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties);
+    return vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayModeProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    VkDisplayKHR display,
+    uint32_t* pPropertyCount,
+    VkDisplayModeProperties2KHR* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
+    vkGetDisplayModeProperties2KHR_VkResult_return = vkEnc->vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
+    return vkGetDisplayModeProperties2KHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayPlaneCapabilities2KHR(
+    VkPhysicalDevice physicalDevice,
+    const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+    VkDisplayPlaneCapabilities2KHR* pCapabilities)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
+    vkGetDisplayPlaneCapabilities2KHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities);
+    return vkGetDisplayPlaneCapabilities2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+static void entry_vkGetImageMemoryRequirements2KHR(
+    VkDevice device,
+    const VkImageMemoryRequirementsInfo2* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetBufferMemoryRequirements2KHR(
+    VkDevice device,
+    const VkBufferMemoryRequirementsInfo2* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetImageSparseMemoryRequirements2KHR(
+    VkDevice device,
+    const VkImageSparseMemoryRequirementsInfo2* pInfo,
+    uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+static VkResult entry_vkCreateSamplerYcbcrConversionKHR(
+    VkDevice device,
+    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
+    vkCreateSamplerYcbcrConversionKHR_VkResult_return = vkEnc->vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
+    return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
+}
+static void entry_vkDestroySamplerYcbcrConversionKHR(
+    VkDevice device,
+    VkSamplerYcbcrConversion ycbcrConversion,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
+}
+#endif
+#ifdef VK_KHR_bind_memory2
+static VkResult entry_vkBindBufferMemory2KHR(
+    VkDevice device,
+    uint32_t bindInfoCount,
+    const VkBindBufferMemoryInfo* pBindInfos)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
+    vkBindBufferMemory2KHR_VkResult_return = vkEnc->vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
+    return vkBindBufferMemory2KHR_VkResult_return;
+}
+static VkResult entry_vkBindImageMemory2KHR(
+    VkDevice device,
+    uint32_t bindInfoCount,
+    const VkBindImageMemoryInfo* pBindInfos)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
+    vkBindImageMemory2KHR_VkResult_return = vkEnc->vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos);
+    return vkBindImageMemory2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance3
+static void entry_vkGetDescriptorSetLayoutSupportKHR(
+    VkDevice device,
+    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    VkDescriptorSetLayoutSupport* pSupport)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
+}
+#endif
+#ifdef VK_KHR_draw_indirect_count
+static void entry_vkCmdDrawIndirectCountKHR(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    VkBuffer countBuffer,
+    VkDeviceSize countBufferOffset,
+    uint32_t maxDrawCount,
+    uint32_t stride)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+static void entry_vkCmdDrawIndexedIndirectCountKHR(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    VkBuffer countBuffer,
+    VkDeviceSize countBufferOffset,
+    uint32_t maxDrawCount,
+    uint32_t stride)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+static VkResult entry_vkGetSwapchainGrallocUsageANDROID(
+    VkDevice device,
+    VkFormat format,
+    VkImageUsageFlags imageUsage,
+    int* grallocUsage)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
+    vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage);
+    return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
+}
+static VkResult entry_vkAcquireImageANDROID(
+    VkDevice device,
+    VkImage image,
+    int nativeFenceFd,
+    VkSemaphore semaphore,
+    VkFence fence)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
+    vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence);
+    return vkAcquireImageANDROID_VkResult_return;
+}
+static VkResult entry_vkQueueSignalReleaseImageANDROID(
+    VkQueue queue,
+    uint32_t waitSemaphoreCount,
+    const VkSemaphore* pWaitSemaphores,
+    VkImage image,
+    int* pNativeFenceFd)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
+    vkQueueSignalReleaseImageANDROID_VkResult_return = vkEnc->vkQueueSignalReleaseImageANDROID(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
+    return vkQueueSignalReleaseImageANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_debug_report
+static VkResult entry_vkCreateDebugReportCallbackEXT(
+    VkInstance instance,
+    const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDebugReportCallbackEXT* pCallback)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
+    vkCreateDebugReportCallbackEXT_VkResult_return = vkEnc->vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
+    return vkCreateDebugReportCallbackEXT_VkResult_return;
+}
+static void entry_vkDestroyDebugReportCallbackEXT(
+    VkInstance instance,
+    VkDebugReportCallbackEXT callback,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
+}
+static void entry_vkDebugReportMessageEXT(
+    VkInstance instance,
+    VkDebugReportFlagsEXT flags,
+    VkDebugReportObjectTypeEXT objectType,
+    uint64_t object,
+    size_t location,
+    int32_t messageCode,
+    const char* pLayerPrefix,
+    const char* pMessage)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
+}
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+static VkResult entry_vkDebugMarkerSetObjectTagEXT(
+    VkDevice device,
+    const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
+    vkDebugMarkerSetObjectTagEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
+    return vkDebugMarkerSetObjectTagEXT_VkResult_return;
+}
+static VkResult entry_vkDebugMarkerSetObjectNameEXT(
+    VkDevice device,
+    const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
+    vkDebugMarkerSetObjectNameEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
+    return vkDebugMarkerSetObjectNameEXT_VkResult_return;
+}
+static void entry_vkCmdDebugMarkerBeginEXT(
+    VkCommandBuffer commandBuffer,
+    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
+}
+static void entry_vkCmdDebugMarkerEndEXT(
+    VkCommandBuffer commandBuffer)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDebugMarkerEndEXT(commandBuffer);
+}
+static void entry_vkCmdDebugMarkerInsertEXT(
+    VkCommandBuffer commandBuffer,
+    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
+}
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+static void entry_vkCmdDrawIndirectCountAMD(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    VkBuffer countBuffer,
+    VkDeviceSize countBufferOffset,
+    uint32_t maxDrawCount,
+    uint32_t stride)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+static void entry_vkCmdDrawIndexedIndirectCountAMD(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    VkBuffer countBuffer,
+    VkDeviceSize countBufferOffset,
+    uint32_t maxDrawCount,
+    uint32_t stride)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+static VkResult entry_vkGetShaderInfoAMD(
+    VkDevice device,
+    VkPipeline pipeline,
+    VkShaderStageFlagBits shaderStage,
+    VkShaderInfoTypeAMD infoType,
+    size_t* pInfoSize,
+    void* pInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
+    vkGetShaderInfoAMD_VkResult_return = vkEnc->vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
+    return vkGetShaderInfoAMD_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+static VkResult entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkImageType type,
+    VkImageTiling tiling,
+    VkImageUsageFlags usage,
+    VkImageCreateFlags flags,
+    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+    VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = vkEnc->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
+    return vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+static VkResult entry_vkGetMemoryWin32HandleNV(
+    VkDevice device,
+    VkDeviceMemory memory,
+    VkExternalMemoryHandleTypeFlagsNV handleType,
+    HANDLE* pHandle)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
+    vkGetMemoryWin32HandleNV_VkResult_return = vkEnc->vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle);
+    return vkGetMemoryWin32HandleNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+static VkResult entry_vkCreateViSurfaceNN(
+    VkInstance instance,
+    const VkViSurfaceCreateInfoNN* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
+    vkCreateViSurfaceNN_VkResult_return = vkEnc->vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
+    return vkCreateViSurfaceNN_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+static void entry_vkCmdBeginConditionalRenderingEXT(
+    VkCommandBuffer commandBuffer,
+    const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
+}
+static void entry_vkCmdEndConditionalRenderingEXT(
+    VkCommandBuffer commandBuffer)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdEndConditionalRenderingEXT(commandBuffer);
+}
+#endif
+#ifdef VK_NVX_device_generated_commands
+static void entry_vkCmdProcessCommandsNVX(
+    VkCommandBuffer commandBuffer,
+    const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
+}
+static void entry_vkCmdReserveSpaceForCommandsNVX(
+    VkCommandBuffer commandBuffer,
+    const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
+}
+static VkResult entry_vkCreateIndirectCommandsLayoutNVX(
+    VkDevice device,
+    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
+    vkCreateIndirectCommandsLayoutNVX_VkResult_return = vkEnc->vkCreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+    return vkCreateIndirectCommandsLayoutNVX_VkResult_return;
+}
+static void entry_vkDestroyIndirectCommandsLayoutNVX(
+    VkDevice device,
+    VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
+}
+static VkResult entry_vkCreateObjectTableNVX(
+    VkDevice device,
+    const VkObjectTableCreateInfoNVX* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkObjectTableNVX* pObjectTable)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
+    vkCreateObjectTableNVX_VkResult_return = vkEnc->vkCreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
+    return vkCreateObjectTableNVX_VkResult_return;
+}
+static void entry_vkDestroyObjectTableNVX(
+    VkDevice device,
+    VkObjectTableNVX objectTable,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyObjectTableNVX(device, objectTable, pAllocator);
+}
+static VkResult entry_vkRegisterObjectsNVX(
+    VkDevice device,
+    VkObjectTableNVX objectTable,
+    uint32_t objectCount,
+    const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+    const uint32_t* pObjectIndices)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
+    vkRegisterObjectsNVX_VkResult_return = vkEnc->vkRegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
+    return vkRegisterObjectsNVX_VkResult_return;
+}
+static VkResult entry_vkUnregisterObjectsNVX(
+    VkDevice device,
+    VkObjectTableNVX objectTable,
+    uint32_t objectCount,
+    const VkObjectEntryTypeNVX* pObjectEntryTypes,
+    const uint32_t* pObjectIndices)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
+    vkUnregisterObjectsNVX_VkResult_return = vkEnc->vkUnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
+    return vkUnregisterObjectsNVX_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    VkPhysicalDevice physicalDevice,
+    VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+    VkDeviceGeneratedCommandsLimitsNVX* pLimits)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits);
+}
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+static void entry_vkCmdSetViewportWScalingNV(
+    VkCommandBuffer commandBuffer,
+    uint32_t firstViewport,
+    uint32_t viewportCount,
+    const VkViewportWScalingNV* pViewportWScalings)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
+}
+#endif
+#ifdef VK_EXT_direct_mode_display
+static VkResult entry_vkReleaseDisplayEXT(
+    VkPhysicalDevice physicalDevice,
+    VkDisplayKHR display)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
+    vkReleaseDisplayEXT_VkResult_return = vkEnc->vkReleaseDisplayEXT(physicalDevice, display);
+    return vkReleaseDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+static VkResult entry_vkAcquireXlibDisplayEXT(
+    VkPhysicalDevice physicalDevice,
+    Display* dpy,
+    VkDisplayKHR display)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
+    vkAcquireXlibDisplayEXT_VkResult_return = vkEnc->vkAcquireXlibDisplayEXT(physicalDevice, dpy, display);
+    return vkAcquireXlibDisplayEXT_VkResult_return;
+}
+static VkResult entry_vkGetRandROutputDisplayEXT(
+    VkPhysicalDevice physicalDevice,
+    Display* dpy,
+    RROutput rrOutput,
+    VkDisplayKHR* pDisplay)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
+    vkGetRandROutputDisplayEXT_VkResult_return = vkEnc->vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
+    return vkGetRandROutputDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_surface_counter
+static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+    VkPhysicalDevice physicalDevice,
+    VkSurfaceKHR surface,
+    VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
+    vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
+    return vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_control
+static VkResult entry_vkDisplayPowerControlEXT(
+    VkDevice device,
+    VkDisplayKHR display,
+    const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
+    vkDisplayPowerControlEXT_VkResult_return = vkEnc->vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo);
+    return vkDisplayPowerControlEXT_VkResult_return;
+}
+static VkResult entry_vkRegisterDeviceEventEXT(
+    VkDevice device,
+    const VkDeviceEventInfoEXT* pDeviceEventInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkFence* pFence)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
+    vkRegisterDeviceEventEXT_VkResult_return = vkEnc->vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
+    return vkRegisterDeviceEventEXT_VkResult_return;
+}
+static VkResult entry_vkRegisterDisplayEventEXT(
+    VkDevice device,
+    VkDisplayKHR display,
+    const VkDisplayEventInfoEXT* pDisplayEventInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkFence* pFence)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
+    vkRegisterDisplayEventEXT_VkResult_return = vkEnc->vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
+    return vkRegisterDisplayEventEXT_VkResult_return;
+}
+static VkResult entry_vkGetSwapchainCounterEXT(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    VkSurfaceCounterFlagBitsEXT counter,
+    uint64_t* pCounterValue)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
+    vkGetSwapchainCounterEXT_VkResult_return = vkEnc->vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
+    return vkGetSwapchainCounterEXT_VkResult_return;
+}
+#endif
+#ifdef VK_GOOGLE_display_timing
+static VkResult entry_vkGetRefreshCycleDurationGOOGLE(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
+    vkGetRefreshCycleDurationGOOGLE_VkResult_return = vkEnc->vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
+    return vkGetRefreshCycleDurationGOOGLE_VkResult_return;
+}
+static VkResult entry_vkGetPastPresentationTimingGOOGLE(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    uint32_t* pPresentationTimingCount,
+    VkPastPresentationTimingGOOGLE* pPresentationTimings)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
+    vkGetPastPresentationTimingGOOGLE_VkResult_return = vkEnc->vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
+    return vkGetPastPresentationTimingGOOGLE_VkResult_return;
+}
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+static void entry_vkCmdSetDiscardRectangleEXT(
+    VkCommandBuffer commandBuffer,
+    uint32_t firstDiscardRectangle,
+    uint32_t discardRectangleCount,
+    const VkRect2D* pDiscardRectangles)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
+}
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+static void entry_vkSetHdrMetadataEXT(
+    VkDevice device,
+    uint32_t swapchainCount,
+    const VkSwapchainKHR* pSwapchains,
+    const VkHdrMetadataEXT* pMetadata)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
+}
+#endif
+#ifdef VK_MVK_ios_surface
+static VkResult entry_vkCreateIOSSurfaceMVK(
+    VkInstance instance,
+    const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
+    vkCreateIOSSurfaceMVK_VkResult_return = vkEnc->vkCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+    return vkCreateIOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_MVK_macos_surface
+static VkResult entry_vkCreateMacOSSurfaceMVK(
+    VkInstance instance,
+    const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
+    vkCreateMacOSSurfaceMVK_VkResult_return = vkEnc->vkCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+    return vkCreateMacOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+static VkResult entry_vkSetDebugUtilsObjectNameEXT(
+    VkDevice device,
+    const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
+    vkSetDebugUtilsObjectNameEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectNameEXT(device, pNameInfo);
+    return vkSetDebugUtilsObjectNameEXT_VkResult_return;
+}
+static VkResult entry_vkSetDebugUtilsObjectTagEXT(
+    VkDevice device,
+    const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
+    vkSetDebugUtilsObjectTagEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectTagEXT(device, pTagInfo);
+    return vkSetDebugUtilsObjectTagEXT_VkResult_return;
+}
+static void entry_vkQueueBeginDebugUtilsLabelEXT(
+    VkQueue queue,
+    const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
+}
+static void entry_vkQueueEndDebugUtilsLabelEXT(
+    VkQueue queue)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkQueueEndDebugUtilsLabelEXT(queue);
+}
+static void entry_vkQueueInsertDebugUtilsLabelEXT(
+    VkQueue queue,
+    const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
+}
+static void entry_vkCmdBeginDebugUtilsLabelEXT(
+    VkCommandBuffer commandBuffer,
+    const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
+}
+static void entry_vkCmdEndDebugUtilsLabelEXT(
+    VkCommandBuffer commandBuffer)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdEndDebugUtilsLabelEXT(commandBuffer);
+}
+static void entry_vkCmdInsertDebugUtilsLabelEXT(
+    VkCommandBuffer commandBuffer,
+    const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
+}
+static VkResult entry_vkCreateDebugUtilsMessengerEXT(
+    VkInstance instance,
+    const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDebugUtilsMessengerEXT* pMessenger)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
+    vkCreateDebugUtilsMessengerEXT_VkResult_return = vkEnc->vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
+    return vkCreateDebugUtilsMessengerEXT_VkResult_return;
+}
+static void entry_vkDestroyDebugUtilsMessengerEXT(
+    VkInstance instance,
+    VkDebugUtilsMessengerEXT messenger,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
+}
+static void entry_vkSubmitDebugUtilsMessageEXT(
+    VkInstance instance,
+    VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+    VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
+}
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+static VkResult entry_vkGetAndroidHardwareBufferPropertiesANDROID(
+    VkDevice device,
+    const AHardwareBuffer* buffer,
+    VkAndroidHardwareBufferPropertiesANDROID* pProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
+    vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = vkEnc->vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties);
+    return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
+}
+static VkResult entry_vkGetMemoryAndroidHardwareBufferANDROID(
+    VkDevice device,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+    AHardwareBuffer** pBuffer)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
+    vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = vkEnc->vkGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
+    return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+static void entry_vkCmdSetSampleLocationsEXT(
+    VkCommandBuffer commandBuffer,
+    const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
+}
+static void entry_vkGetPhysicalDeviceMultisamplePropertiesEXT(
+    VkPhysicalDevice physicalDevice,
+    VkSampleCountFlagBits samples,
+    VkMultisamplePropertiesEXT* pMultisampleProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties);
+}
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+static VkResult entry_vkCreateValidationCacheEXT(
+    VkDevice device,
+    const VkValidationCacheCreateInfoEXT* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkValidationCacheEXT* pValidationCache)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
+    vkCreateValidationCacheEXT_VkResult_return = vkEnc->vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
+    return vkCreateValidationCacheEXT_VkResult_return;
+}
+static void entry_vkDestroyValidationCacheEXT(
+    VkDevice device,
+    VkValidationCacheEXT validationCache,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
+}
+static VkResult entry_vkMergeValidationCachesEXT(
+    VkDevice device,
+    VkValidationCacheEXT dstCache,
+    uint32_t srcCacheCount,
+    const VkValidationCacheEXT* pSrcCaches)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
+    vkMergeValidationCachesEXT_VkResult_return = vkEnc->vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
+    return vkMergeValidationCachesEXT_VkResult_return;
+}
+static VkResult entry_vkGetValidationCacheDataEXT(
+    VkDevice device,
+    VkValidationCacheEXT validationCache,
+    size_t* pDataSize,
+    void* pData)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
+    vkGetValidationCacheDataEXT_VkResult_return = vkEnc->vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
+    return vkGetValidationCacheDataEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+static VkResult entry_vkGetMemoryHostPointerPropertiesEXT(
+    VkDevice device,
+    VkExternalMemoryHandleTypeFlagBits handleType,
+    const void* pHostPointer,
+    VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
+    vkGetMemoryHostPointerPropertiesEXT_VkResult_return = vkEnc->vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
+    return vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_buffer_marker
+static void entry_vkCmdWriteBufferMarkerAMD(
+    VkCommandBuffer commandBuffer,
+    VkPipelineStageFlagBits pipelineStage,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
+    uint32_t marker)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
+}
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+static void entry_vkCmdSetCheckpointNV(
+    VkCommandBuffer commandBuffer,
+    const void* pCheckpointMarker)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
+}
+static void entry_vkGetQueueCheckpointDataNV(
+    VkQueue queue,
+    uint32_t* pCheckpointDataCount,
+    VkCheckpointDataNV* pCheckpointData)
+{
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
+}
+#endif
+void* goldfish_vulkan_get_proc_address(const char* name){
+#ifdef VK_VERSION_1_0
+    if (!strcmp(name, "vkCreateInstance"))
+    {
+        return (void*)entry_vkCreateInstance;
+    }
+    if (!strcmp(name, "vkDestroyInstance"))
+    {
+        return (void*)entry_vkDestroyInstance;
+    }
+    if (!strcmp(name, "vkEnumeratePhysicalDevices"))
+    {
+        return (void*)entry_vkEnumeratePhysicalDevices;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceFeatures"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceFeatures;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceFormatProperties;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceProperties"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceProperties;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
+    }
+    if (!strcmp(name, "vkGetInstanceProcAddr"))
+    {
+        return (void*)entry_vkGetInstanceProcAddr;
+    }
+    if (!strcmp(name, "vkGetDeviceProcAddr"))
+    {
+        return (void*)entry_vkGetDeviceProcAddr;
+    }
+    if (!strcmp(name, "vkCreateDevice"))
+    {
+        return (void*)entry_vkCreateDevice;
+    }
+    if (!strcmp(name, "vkDestroyDevice"))
+    {
+        return (void*)entry_vkDestroyDevice;
+    }
+    if (!strcmp(name, "vkEnumerateInstanceExtensionProperties"))
+    {
+        return (void*)entry_vkEnumerateInstanceExtensionProperties;
+    }
+    if (!strcmp(name, "vkEnumerateDeviceExtensionProperties"))
+    {
+        return (void*)entry_vkEnumerateDeviceExtensionProperties;
+    }
+    if (!strcmp(name, "vkEnumerateInstanceLayerProperties"))
+    {
+        return (void*)entry_vkEnumerateInstanceLayerProperties;
+    }
+    if (!strcmp(name, "vkEnumerateDeviceLayerProperties"))
+    {
+        return (void*)entry_vkEnumerateDeviceLayerProperties;
+    }
+    if (!strcmp(name, "vkGetDeviceQueue"))
+    {
+        return (void*)entry_vkGetDeviceQueue;
+    }
+    if (!strcmp(name, "vkQueueSubmit"))
+    {
+        return (void*)entry_vkQueueSubmit;
+    }
+    if (!strcmp(name, "vkQueueWaitIdle"))
+    {
+        return (void*)entry_vkQueueWaitIdle;
+    }
+    if (!strcmp(name, "vkDeviceWaitIdle"))
+    {
+        return (void*)entry_vkDeviceWaitIdle;
+    }
+    if (!strcmp(name, "vkAllocateMemory"))
+    {
+        return (void*)entry_vkAllocateMemory;
+    }
+    if (!strcmp(name, "vkFreeMemory"))
+    {
+        return (void*)entry_vkFreeMemory;
+    }
+    if (!strcmp(name, "vkMapMemory"))
+    {
+        return (void*)entry_vkMapMemory;
+    }
+    if (!strcmp(name, "vkUnmapMemory"))
+    {
+        return (void*)entry_vkUnmapMemory;
+    }
+    if (!strcmp(name, "vkFlushMappedMemoryRanges"))
+    {
+        return (void*)entry_vkFlushMappedMemoryRanges;
+    }
+    if (!strcmp(name, "vkInvalidateMappedMemoryRanges"))
+    {
+        return (void*)entry_vkInvalidateMappedMemoryRanges;
+    }
+    if (!strcmp(name, "vkGetDeviceMemoryCommitment"))
+    {
+        return (void*)entry_vkGetDeviceMemoryCommitment;
+    }
+    if (!strcmp(name, "vkBindBufferMemory"))
+    {
+        return (void*)entry_vkBindBufferMemory;
+    }
+    if (!strcmp(name, "vkBindImageMemory"))
+    {
+        return (void*)entry_vkBindImageMemory;
+    }
+    if (!strcmp(name, "vkGetBufferMemoryRequirements"))
+    {
+        return (void*)entry_vkGetBufferMemoryRequirements;
+    }
+    if (!strcmp(name, "vkGetImageMemoryRequirements"))
+    {
+        return (void*)entry_vkGetImageMemoryRequirements;
+    }
+    if (!strcmp(name, "vkGetImageSparseMemoryRequirements"))
+    {
+        return (void*)entry_vkGetImageSparseMemoryRequirements;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
+    }
+    if (!strcmp(name, "vkQueueBindSparse"))
+    {
+        return (void*)entry_vkQueueBindSparse;
+    }
+    if (!strcmp(name, "vkCreateFence"))
+    {
+        return (void*)entry_vkCreateFence;
+    }
+    if (!strcmp(name, "vkDestroyFence"))
+    {
+        return (void*)entry_vkDestroyFence;
+    }
+    if (!strcmp(name, "vkResetFences"))
+    {
+        return (void*)entry_vkResetFences;
+    }
+    if (!strcmp(name, "vkGetFenceStatus"))
+    {
+        return (void*)entry_vkGetFenceStatus;
+    }
+    if (!strcmp(name, "vkWaitForFences"))
+    {
+        return (void*)entry_vkWaitForFences;
+    }
+    if (!strcmp(name, "vkCreateSemaphore"))
+    {
+        return (void*)entry_vkCreateSemaphore;
+    }
+    if (!strcmp(name, "vkDestroySemaphore"))
+    {
+        return (void*)entry_vkDestroySemaphore;
+    }
+    if (!strcmp(name, "vkCreateEvent"))
+    {
+        return (void*)entry_vkCreateEvent;
+    }
+    if (!strcmp(name, "vkDestroyEvent"))
+    {
+        return (void*)entry_vkDestroyEvent;
+    }
+    if (!strcmp(name, "vkGetEventStatus"))
+    {
+        return (void*)entry_vkGetEventStatus;
+    }
+    if (!strcmp(name, "vkSetEvent"))
+    {
+        return (void*)entry_vkSetEvent;
+    }
+    if (!strcmp(name, "vkResetEvent"))
+    {
+        return (void*)entry_vkResetEvent;
+    }
+    if (!strcmp(name, "vkCreateQueryPool"))
+    {
+        return (void*)entry_vkCreateQueryPool;
+    }
+    if (!strcmp(name, "vkDestroyQueryPool"))
+    {
+        return (void*)entry_vkDestroyQueryPool;
+    }
+    if (!strcmp(name, "vkGetQueryPoolResults"))
+    {
+        return (void*)entry_vkGetQueryPoolResults;
+    }
+    if (!strcmp(name, "vkCreateBuffer"))
+    {
+        return (void*)entry_vkCreateBuffer;
+    }
+    if (!strcmp(name, "vkDestroyBuffer"))
+    {
+        return (void*)entry_vkDestroyBuffer;
+    }
+    if (!strcmp(name, "vkCreateBufferView"))
+    {
+        return (void*)entry_vkCreateBufferView;
+    }
+    if (!strcmp(name, "vkDestroyBufferView"))
+    {
+        return (void*)entry_vkDestroyBufferView;
+    }
+    if (!strcmp(name, "vkCreateImage"))
+    {
+        return (void*)entry_vkCreateImage;
+    }
+    if (!strcmp(name, "vkDestroyImage"))
+    {
+        return (void*)entry_vkDestroyImage;
+    }
+    if (!strcmp(name, "vkGetImageSubresourceLayout"))
+    {
+        return (void*)entry_vkGetImageSubresourceLayout;
+    }
+    if (!strcmp(name, "vkCreateImageView"))
+    {
+        return (void*)entry_vkCreateImageView;
+    }
+    if (!strcmp(name, "vkDestroyImageView"))
+    {
+        return (void*)entry_vkDestroyImageView;
+    }
+    if (!strcmp(name, "vkCreateShaderModule"))
+    {
+        return (void*)entry_vkCreateShaderModule;
+    }
+    if (!strcmp(name, "vkDestroyShaderModule"))
+    {
+        return (void*)entry_vkDestroyShaderModule;
+    }
+    if (!strcmp(name, "vkCreatePipelineCache"))
+    {
+        return (void*)entry_vkCreatePipelineCache;
+    }
+    if (!strcmp(name, "vkDestroyPipelineCache"))
+    {
+        return (void*)entry_vkDestroyPipelineCache;
+    }
+    if (!strcmp(name, "vkGetPipelineCacheData"))
+    {
+        return (void*)entry_vkGetPipelineCacheData;
+    }
+    if (!strcmp(name, "vkMergePipelineCaches"))
+    {
+        return (void*)entry_vkMergePipelineCaches;
+    }
+    if (!strcmp(name, "vkCreateGraphicsPipelines"))
+    {
+        return (void*)entry_vkCreateGraphicsPipelines;
+    }
+    if (!strcmp(name, "vkCreateComputePipelines"))
+    {
+        return (void*)entry_vkCreateComputePipelines;
+    }
+    if (!strcmp(name, "vkDestroyPipeline"))
+    {
+        return (void*)entry_vkDestroyPipeline;
+    }
+    if (!strcmp(name, "vkCreatePipelineLayout"))
+    {
+        return (void*)entry_vkCreatePipelineLayout;
+    }
+    if (!strcmp(name, "vkDestroyPipelineLayout"))
+    {
+        return (void*)entry_vkDestroyPipelineLayout;
+    }
+    if (!strcmp(name, "vkCreateSampler"))
+    {
+        return (void*)entry_vkCreateSampler;
+    }
+    if (!strcmp(name, "vkDestroySampler"))
+    {
+        return (void*)entry_vkDestroySampler;
+    }
+    if (!strcmp(name, "vkCreateDescriptorSetLayout"))
+    {
+        return (void*)entry_vkCreateDescriptorSetLayout;
+    }
+    if (!strcmp(name, "vkDestroyDescriptorSetLayout"))
+    {
+        return (void*)entry_vkDestroyDescriptorSetLayout;
+    }
+    if (!strcmp(name, "vkCreateDescriptorPool"))
+    {
+        return (void*)entry_vkCreateDescriptorPool;
+    }
+    if (!strcmp(name, "vkDestroyDescriptorPool"))
+    {
+        return (void*)entry_vkDestroyDescriptorPool;
+    }
+    if (!strcmp(name, "vkResetDescriptorPool"))
+    {
+        return (void*)entry_vkResetDescriptorPool;
+    }
+    if (!strcmp(name, "vkAllocateDescriptorSets"))
+    {
+        return (void*)entry_vkAllocateDescriptorSets;
+    }
+    if (!strcmp(name, "vkFreeDescriptorSets"))
+    {
+        return (void*)entry_vkFreeDescriptorSets;
+    }
+    if (!strcmp(name, "vkUpdateDescriptorSets"))
+    {
+        return (void*)entry_vkUpdateDescriptorSets;
+    }
+    if (!strcmp(name, "vkCreateFramebuffer"))
+    {
+        return (void*)entry_vkCreateFramebuffer;
+    }
+    if (!strcmp(name, "vkDestroyFramebuffer"))
+    {
+        return (void*)entry_vkDestroyFramebuffer;
+    }
+    if (!strcmp(name, "vkCreateRenderPass"))
+    {
+        return (void*)entry_vkCreateRenderPass;
+    }
+    if (!strcmp(name, "vkDestroyRenderPass"))
+    {
+        return (void*)entry_vkDestroyRenderPass;
+    }
+    if (!strcmp(name, "vkGetRenderAreaGranularity"))
+    {
+        return (void*)entry_vkGetRenderAreaGranularity;
+    }
+    if (!strcmp(name, "vkCreateCommandPool"))
+    {
+        return (void*)entry_vkCreateCommandPool;
+    }
+    if (!strcmp(name, "vkDestroyCommandPool"))
+    {
+        return (void*)entry_vkDestroyCommandPool;
+    }
+    if (!strcmp(name, "vkResetCommandPool"))
+    {
+        return (void*)entry_vkResetCommandPool;
+    }
+    if (!strcmp(name, "vkAllocateCommandBuffers"))
+    {
+        return (void*)entry_vkAllocateCommandBuffers;
+    }
+    if (!strcmp(name, "vkFreeCommandBuffers"))
+    {
+        return (void*)entry_vkFreeCommandBuffers;
+    }
+    if (!strcmp(name, "vkBeginCommandBuffer"))
+    {
+        return (void*)entry_vkBeginCommandBuffer;
+    }
+    if (!strcmp(name, "vkEndCommandBuffer"))
+    {
+        return (void*)entry_vkEndCommandBuffer;
+    }
+    if (!strcmp(name, "vkResetCommandBuffer"))
+    {
+        return (void*)entry_vkResetCommandBuffer;
+    }
+    if (!strcmp(name, "vkCmdBindPipeline"))
+    {
+        return (void*)entry_vkCmdBindPipeline;
+    }
+    if (!strcmp(name, "vkCmdSetViewport"))
+    {
+        return (void*)entry_vkCmdSetViewport;
+    }
+    if (!strcmp(name, "vkCmdSetScissor"))
+    {
+        return (void*)entry_vkCmdSetScissor;
+    }
+    if (!strcmp(name, "vkCmdSetLineWidth"))
+    {
+        return (void*)entry_vkCmdSetLineWidth;
+    }
+    if (!strcmp(name, "vkCmdSetDepthBias"))
+    {
+        return (void*)entry_vkCmdSetDepthBias;
+    }
+    if (!strcmp(name, "vkCmdSetBlendConstants"))
+    {
+        return (void*)entry_vkCmdSetBlendConstants;
+    }
+    if (!strcmp(name, "vkCmdSetDepthBounds"))
+    {
+        return (void*)entry_vkCmdSetDepthBounds;
+    }
+    if (!strcmp(name, "vkCmdSetStencilCompareMask"))
+    {
+        return (void*)entry_vkCmdSetStencilCompareMask;
+    }
+    if (!strcmp(name, "vkCmdSetStencilWriteMask"))
+    {
+        return (void*)entry_vkCmdSetStencilWriteMask;
+    }
+    if (!strcmp(name, "vkCmdSetStencilReference"))
+    {
+        return (void*)entry_vkCmdSetStencilReference;
+    }
+    if (!strcmp(name, "vkCmdBindDescriptorSets"))
+    {
+        return (void*)entry_vkCmdBindDescriptorSets;
+    }
+    if (!strcmp(name, "vkCmdBindIndexBuffer"))
+    {
+        return (void*)entry_vkCmdBindIndexBuffer;
+    }
+    if (!strcmp(name, "vkCmdBindVertexBuffers"))
+    {
+        return (void*)entry_vkCmdBindVertexBuffers;
+    }
+    if (!strcmp(name, "vkCmdDraw"))
+    {
+        return (void*)entry_vkCmdDraw;
+    }
+    if (!strcmp(name, "vkCmdDrawIndexed"))
+    {
+        return (void*)entry_vkCmdDrawIndexed;
+    }
+    if (!strcmp(name, "vkCmdDrawIndirect"))
+    {
+        return (void*)entry_vkCmdDrawIndirect;
+    }
+    if (!strcmp(name, "vkCmdDrawIndexedIndirect"))
+    {
+        return (void*)entry_vkCmdDrawIndexedIndirect;
+    }
+    if (!strcmp(name, "vkCmdDispatch"))
+    {
+        return (void*)entry_vkCmdDispatch;
+    }
+    if (!strcmp(name, "vkCmdDispatchIndirect"))
+    {
+        return (void*)entry_vkCmdDispatchIndirect;
+    }
+    if (!strcmp(name, "vkCmdCopyBuffer"))
+    {
+        return (void*)entry_vkCmdCopyBuffer;
+    }
+    if (!strcmp(name, "vkCmdCopyImage"))
+    {
+        return (void*)entry_vkCmdCopyImage;
+    }
+    if (!strcmp(name, "vkCmdBlitImage"))
+    {
+        return (void*)entry_vkCmdBlitImage;
+    }
+    if (!strcmp(name, "vkCmdCopyBufferToImage"))
+    {
+        return (void*)entry_vkCmdCopyBufferToImage;
+    }
+    if (!strcmp(name, "vkCmdCopyImageToBuffer"))
+    {
+        return (void*)entry_vkCmdCopyImageToBuffer;
+    }
+    if (!strcmp(name, "vkCmdUpdateBuffer"))
+    {
+        return (void*)entry_vkCmdUpdateBuffer;
+    }
+    if (!strcmp(name, "vkCmdFillBuffer"))
+    {
+        return (void*)entry_vkCmdFillBuffer;
+    }
+    if (!strcmp(name, "vkCmdClearColorImage"))
+    {
+        return (void*)entry_vkCmdClearColorImage;
+    }
+    if (!strcmp(name, "vkCmdClearDepthStencilImage"))
+    {
+        return (void*)entry_vkCmdClearDepthStencilImage;
+    }
+    if (!strcmp(name, "vkCmdClearAttachments"))
+    {
+        return (void*)entry_vkCmdClearAttachments;
+    }
+    if (!strcmp(name, "vkCmdResolveImage"))
+    {
+        return (void*)entry_vkCmdResolveImage;
+    }
+    if (!strcmp(name, "vkCmdSetEvent"))
+    {
+        return (void*)entry_vkCmdSetEvent;
+    }
+    if (!strcmp(name, "vkCmdResetEvent"))
+    {
+        return (void*)entry_vkCmdResetEvent;
+    }
+    if (!strcmp(name, "vkCmdWaitEvents"))
+    {
+        return (void*)entry_vkCmdWaitEvents;
+    }
+    if (!strcmp(name, "vkCmdPipelineBarrier"))
+    {
+        return (void*)entry_vkCmdPipelineBarrier;
+    }
+    if (!strcmp(name, "vkCmdBeginQuery"))
+    {
+        return (void*)entry_vkCmdBeginQuery;
+    }
+    if (!strcmp(name, "vkCmdEndQuery"))
+    {
+        return (void*)entry_vkCmdEndQuery;
+    }
+    if (!strcmp(name, "vkCmdResetQueryPool"))
+    {
+        return (void*)entry_vkCmdResetQueryPool;
+    }
+    if (!strcmp(name, "vkCmdWriteTimestamp"))
+    {
+        return (void*)entry_vkCmdWriteTimestamp;
+    }
+    if (!strcmp(name, "vkCmdCopyQueryPoolResults"))
+    {
+        return (void*)entry_vkCmdCopyQueryPoolResults;
+    }
+    if (!strcmp(name, "vkCmdPushConstants"))
+    {
+        return (void*)entry_vkCmdPushConstants;
+    }
+    if (!strcmp(name, "vkCmdBeginRenderPass"))
+    {
+        return (void*)entry_vkCmdBeginRenderPass;
+    }
+    if (!strcmp(name, "vkCmdNextSubpass"))
+    {
+        return (void*)entry_vkCmdNextSubpass;
+    }
+    if (!strcmp(name, "vkCmdEndRenderPass"))
+    {
+        return (void*)entry_vkCmdEndRenderPass;
+    }
+    if (!strcmp(name, "vkCmdExecuteCommands"))
+    {
+        return (void*)entry_vkCmdExecuteCommands;
+    }
+#endif
+#ifdef VK_VERSION_1_1
+    if (!strcmp(name, "vkEnumerateInstanceVersion"))
+    {
+        return (void*)entry_vkEnumerateInstanceVersion;
+    }
+    if (!strcmp(name, "vkBindBufferMemory2"))
+    {
+        return (void*)entry_vkBindBufferMemory2;
+    }
+    if (!strcmp(name, "vkBindImageMemory2"))
+    {
+        return (void*)entry_vkBindImageMemory2;
+    }
+    if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures"))
+    {
+        return (void*)entry_vkGetDeviceGroupPeerMemoryFeatures;
+    }
+    if (!strcmp(name, "vkCmdSetDeviceMask"))
+    {
+        return (void*)entry_vkCmdSetDeviceMask;
+    }
+    if (!strcmp(name, "vkCmdDispatchBase"))
+    {
+        return (void*)entry_vkCmdDispatchBase;
+    }
+    if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups"))
+    {
+        return nullptr;
+    }
+    if (!strcmp(name, "vkGetImageMemoryRequirements2"))
+    {
+        return (void*)entry_vkGetImageMemoryRequirements2;
+    }
+    if (!strcmp(name, "vkGetBufferMemoryRequirements2"))
+    {
+        return (void*)entry_vkGetBufferMemoryRequirements2;
+    }
+    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2"))
+    {
+        return (void*)entry_vkGetImageSparseMemoryRequirements2;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceFeatures2;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceProperties2"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceProperties2;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceFormatProperties2;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceImageFormatProperties2;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceMemoryProperties2;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2;
+    }
+    if (!strcmp(name, "vkTrimCommandPool"))
+    {
+        return (void*)entry_vkTrimCommandPool;
+    }
+    if (!strcmp(name, "vkGetDeviceQueue2"))
+    {
+        return (void*)entry_vkGetDeviceQueue2;
+    }
+    if (!strcmp(name, "vkCreateSamplerYcbcrConversion"))
+    {
+        return (void*)entry_vkCreateSamplerYcbcrConversion;
+    }
+    if (!strcmp(name, "vkDestroySamplerYcbcrConversion"))
+    {
+        return (void*)entry_vkDestroySamplerYcbcrConversion;
+    }
+    if (!strcmp(name, "vkCreateDescriptorUpdateTemplate"))
+    {
+        return (void*)entry_vkCreateDescriptorUpdateTemplate;
+    }
+    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate"))
+    {
+        return (void*)entry_vkDestroyDescriptorUpdateTemplate;
+    }
+    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate"))
+    {
+        return (void*)entry_vkUpdateDescriptorSetWithTemplate;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceExternalBufferProperties;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceExternalFenceProperties;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties;
+    }
+    if (!strcmp(name, "vkGetDescriptorSetLayoutSupport"))
+    {
+        return (void*)entry_vkGetDescriptorSetLayoutSupport;
+    }
+#endif
+#ifdef VK_KHR_surface
+    if (!strcmp(name, "vkDestroySurfaceKHR"))
+    {
+        return (void*)entry_vkDestroySurfaceKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceSurfaceSupportKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceSurfaceFormatsKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceSurfacePresentModesKHR;
+    }
+#endif
+#ifdef VK_KHR_swapchain
+    if (!strcmp(name, "vkCreateSwapchainKHR"))
+    {
+        return (void*)entry_vkCreateSwapchainKHR;
+    }
+    if (!strcmp(name, "vkDestroySwapchainKHR"))
+    {
+        return (void*)entry_vkDestroySwapchainKHR;
+    }
+    if (!strcmp(name, "vkGetSwapchainImagesKHR"))
+    {
+        return (void*)entry_vkGetSwapchainImagesKHR;
+    }
+    if (!strcmp(name, "vkAcquireNextImageKHR"))
+    {
+        return (void*)entry_vkAcquireNextImageKHR;
+    }
+    if (!strcmp(name, "vkQueuePresentKHR"))
+    {
+        return (void*)entry_vkQueuePresentKHR;
+    }
+    if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR"))
+    {
+        return (void*)entry_vkGetDeviceGroupPresentCapabilitiesKHR;
+    }
+    if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR"))
+    {
+        return (void*)entry_vkGetDeviceGroupSurfacePresentModesKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDevicePresentRectanglesKHR;
+    }
+    if (!strcmp(name, "vkAcquireNextImage2KHR"))
+    {
+        return (void*)entry_vkAcquireNextImage2KHR;
+    }
+#endif
+#ifdef VK_KHR_display
+    if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceDisplayPropertiesKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+    }
+    if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR"))
+    {
+        return (void*)entry_vkGetDisplayPlaneSupportedDisplaysKHR;
+    }
+    if (!strcmp(name, "vkGetDisplayModePropertiesKHR"))
+    {
+        return (void*)entry_vkGetDisplayModePropertiesKHR;
+    }
+    if (!strcmp(name, "vkCreateDisplayModeKHR"))
+    {
+        return (void*)entry_vkCreateDisplayModeKHR;
+    }
+    if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR"))
+    {
+        return (void*)entry_vkGetDisplayPlaneCapabilitiesKHR;
+    }
+    if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR"))
+    {
+        return (void*)entry_vkCreateDisplayPlaneSurfaceKHR;
+    }
+#endif
+#ifdef VK_KHR_display_swapchain
+    if (!strcmp(name, "vkCreateSharedSwapchainsKHR"))
+    {
+        return (void*)entry_vkCreateSharedSwapchainsKHR;
+    }
+#endif
+#ifdef VK_KHR_xlib_surface
+    if (!strcmp(name, "vkCreateXlibSurfaceKHR"))
+    {
+        return (void*)entry_vkCreateXlibSurfaceKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceXlibPresentationSupportKHR;
+    }
+#endif
+#ifdef VK_KHR_xcb_surface
+    if (!strcmp(name, "vkCreateXcbSurfaceKHR"))
+    {
+        return (void*)entry_vkCreateXcbSurfaceKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceXcbPresentationSupportKHR;
+    }
+#endif
+#ifdef VK_KHR_wayland_surface
+    if (!strcmp(name, "vkCreateWaylandSurfaceKHR"))
+    {
+        return (void*)entry_vkCreateWaylandSurfaceKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR;
+    }
+#endif
+#ifdef VK_KHR_mir_surface
+    if (!strcmp(name, "vkCreateMirSurfaceKHR"))
+    {
+        return (void*)entry_vkCreateMirSurfaceKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceMirPresentationSupportKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceMirPresentationSupportKHR;
+    }
+#endif
+#ifdef VK_KHR_android_surface
+    if (!strcmp(name, "vkCreateAndroidSurfaceKHR"))
+    {
+        return (void*)entry_vkCreateAndroidSurfaceKHR;
+    }
+#endif
+#ifdef VK_KHR_win32_surface
+    if (!strcmp(name, "vkCreateWin32SurfaceKHR"))
+    {
+        return (void*)entry_vkCreateWin32SurfaceKHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceWin32PresentationSupportKHR;
+    }
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceFeatures2KHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceProperties2KHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
+    }
+#endif
+#ifdef VK_KHR_device_group
+    if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR"))
+    {
+        return (void*)entry_vkGetDeviceGroupPeerMemoryFeaturesKHR;
+    }
+    if (!strcmp(name, "vkCmdSetDeviceMaskKHR"))
+    {
+        return (void*)entry_vkCmdSetDeviceMaskKHR;
+    }
+    if (!strcmp(name, "vkCmdDispatchBaseKHR"))
+    {
+        return (void*)entry_vkCmdDispatchBaseKHR;
+    }
+#endif
+#ifdef VK_KHR_maintenance1
+    if (!strcmp(name, "vkTrimCommandPoolKHR"))
+    {
+        return (void*)entry_vkTrimCommandPoolKHR;
+    }
+#endif
+#ifdef VK_KHR_device_group_creation
+    if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR"))
+    {
+        return (void*)entry_vkEnumeratePhysicalDeviceGroupsKHR;
+    }
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
+    }
+#endif
+#ifdef VK_KHR_external_memory_win32
+    if (!strcmp(name, "vkGetMemoryWin32HandleKHR"))
+    {
+        return (void*)entry_vkGetMemoryWin32HandleKHR;
+    }
+    if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR"))
+    {
+        return (void*)entry_vkGetMemoryWin32HandlePropertiesKHR;
+    }
+#endif
+#ifdef VK_KHR_external_memory_fd
+    if (!strcmp(name, "vkGetMemoryFdKHR"))
+    {
+        return (void*)entry_vkGetMemoryFdKHR;
+    }
+    if (!strcmp(name, "vkGetMemoryFdPropertiesKHR"))
+    {
+        return (void*)entry_vkGetMemoryFdPropertiesKHR;
+    }
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+    }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+    if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR"))
+    {
+        return (void*)entry_vkImportSemaphoreWin32HandleKHR;
+    }
+    if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR"))
+    {
+        return (void*)entry_vkGetSemaphoreWin32HandleKHR;
+    }
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+    if (!strcmp(name, "vkImportSemaphoreFdKHR"))
+    {
+        return (void*)entry_vkImportSemaphoreFdKHR;
+    }
+    if (!strcmp(name, "vkGetSemaphoreFdKHR"))
+    {
+        return (void*)entry_vkGetSemaphoreFdKHR;
+    }
+#endif
+#ifdef VK_KHR_push_descriptor
+    if (!strcmp(name, "vkCmdPushDescriptorSetKHR"))
+    {
+        return (void*)entry_vkCmdPushDescriptorSetKHR;
+    }
+    if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR"))
+    {
+        return (void*)entry_vkCmdPushDescriptorSetWithTemplateKHR;
+    }
+#endif
+#ifdef VK_KHR_descriptor_update_template
+    if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR"))
+    {
+        return (void*)entry_vkCreateDescriptorUpdateTemplateKHR;
+    }
+    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR"))
+    {
+        return (void*)entry_vkDestroyDescriptorUpdateTemplateKHR;
+    }
+    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR"))
+    {
+        return (void*)entry_vkUpdateDescriptorSetWithTemplateKHR;
+    }
+#endif
+#ifdef VK_KHR_create_renderpass2
+    if (!strcmp(name, "vkCreateRenderPass2KHR"))
+    {
+        return (void*)entry_vkCreateRenderPass2KHR;
+    }
+    if (!strcmp(name, "vkCmdBeginRenderPass2KHR"))
+    {
+        return (void*)entry_vkCmdBeginRenderPass2KHR;
+    }
+    if (!strcmp(name, "vkCmdNextSubpass2KHR"))
+    {
+        return (void*)entry_vkCmdNextSubpass2KHR;
+    }
+    if (!strcmp(name, "vkCmdEndRenderPass2KHR"))
+    {
+        return (void*)entry_vkCmdEndRenderPass2KHR;
+    }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+    if (!strcmp(name, "vkGetSwapchainStatusKHR"))
+    {
+        return (void*)entry_vkGetSwapchainStatusKHR;
+    }
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+    if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR;
+    }
+#endif
+#ifdef VK_KHR_external_fence_win32
+    if (!strcmp(name, "vkImportFenceWin32HandleKHR"))
+    {
+        return (void*)entry_vkImportFenceWin32HandleKHR;
+    }
+    if (!strcmp(name, "vkGetFenceWin32HandleKHR"))
+    {
+        return (void*)entry_vkGetFenceWin32HandleKHR;
+    }
+#endif
+#ifdef VK_KHR_external_fence_fd
+    if (!strcmp(name, "vkImportFenceFdKHR"))
+    {
+        return (void*)entry_vkImportFenceFdKHR;
+    }
+    if (!strcmp(name, "vkGetFenceFdKHR"))
+    {
+        return (void*)entry_vkGetFenceFdKHR;
+    }
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+    if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceSurfaceFormats2KHR;
+    }
+#endif
+#ifdef VK_KHR_get_display_properties2
+    if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceDisplayProperties2KHR;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
+    }
+    if (!strcmp(name, "vkGetDisplayModeProperties2KHR"))
+    {
+        return (void*)entry_vkGetDisplayModeProperties2KHR;
+    }
+    if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR"))
+    {
+        return (void*)entry_vkGetDisplayPlaneCapabilities2KHR;
+    }
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+    if (!strcmp(name, "vkGetImageMemoryRequirements2KHR"))
+    {
+        return (void*)entry_vkGetImageMemoryRequirements2KHR;
+    }
+    if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR"))
+    {
+        return (void*)entry_vkGetBufferMemoryRequirements2KHR;
+    }
+    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR"))
+    {
+        return (void*)entry_vkGetImageSparseMemoryRequirements2KHR;
+    }
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+    if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR"))
+    {
+        return (void*)entry_vkCreateSamplerYcbcrConversionKHR;
+    }
+    if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR"))
+    {
+        return (void*)entry_vkDestroySamplerYcbcrConversionKHR;
+    }
+#endif
+#ifdef VK_KHR_bind_memory2
+    if (!strcmp(name, "vkBindBufferMemory2KHR"))
+    {
+        return (void*)entry_vkBindBufferMemory2KHR;
+    }
+    if (!strcmp(name, "vkBindImageMemory2KHR"))
+    {
+        return (void*)entry_vkBindImageMemory2KHR;
+    }
+#endif
+#ifdef VK_KHR_maintenance3
+    if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR"))
+    {
+        return (void*)entry_vkGetDescriptorSetLayoutSupportKHR;
+    }
+#endif
+#ifdef VK_KHR_draw_indirect_count
+    if (!strcmp(name, "vkCmdDrawIndirectCountKHR"))
+    {
+        return (void*)entry_vkCmdDrawIndirectCountKHR;
+    }
+    if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR"))
+    {
+        return (void*)entry_vkCmdDrawIndexedIndirectCountKHR;
+    }
+#endif
+#ifdef VK_ANDROID_native_buffer
+    if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID"))
+    {
+        return (void*)entry_vkGetSwapchainGrallocUsageANDROID;
+    }
+    if (!strcmp(name, "vkAcquireImageANDROID"))
+    {
+        return (void*)entry_vkAcquireImageANDROID;
+    }
+    if (!strcmp(name, "vkQueueSignalReleaseImageANDROID"))
+    {
+        return (void*)entry_vkQueueSignalReleaseImageANDROID;
+    }
+#endif
+#ifdef VK_EXT_debug_report
+    if (!strcmp(name, "vkCreateDebugReportCallbackEXT"))
+    {
+        return (void*)entry_vkCreateDebugReportCallbackEXT;
+    }
+    if (!strcmp(name, "vkDestroyDebugReportCallbackEXT"))
+    {
+        return (void*)entry_vkDestroyDebugReportCallbackEXT;
+    }
+    if (!strcmp(name, "vkDebugReportMessageEXT"))
+    {
+        return (void*)entry_vkDebugReportMessageEXT;
+    }
+#endif
+#ifdef VK_EXT_debug_marker
+    if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT"))
+    {
+        return (void*)entry_vkDebugMarkerSetObjectTagEXT;
+    }
+    if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT"))
+    {
+        return (void*)entry_vkDebugMarkerSetObjectNameEXT;
+    }
+    if (!strcmp(name, "vkCmdDebugMarkerBeginEXT"))
+    {
+        return (void*)entry_vkCmdDebugMarkerBeginEXT;
+    }
+    if (!strcmp(name, "vkCmdDebugMarkerEndEXT"))
+    {
+        return (void*)entry_vkCmdDebugMarkerEndEXT;
+    }
+    if (!strcmp(name, "vkCmdDebugMarkerInsertEXT"))
+    {
+        return (void*)entry_vkCmdDebugMarkerInsertEXT;
+    }
+#endif
+#ifdef VK_AMD_draw_indirect_count
+    if (!strcmp(name, "vkCmdDrawIndirectCountAMD"))
+    {
+        return (void*)entry_vkCmdDrawIndirectCountAMD;
+    }
+    if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD"))
+    {
+        return (void*)entry_vkCmdDrawIndexedIndirectCountAMD;
+    }
+#endif
+#ifdef VK_AMD_shader_info
+    if (!strcmp(name, "vkGetShaderInfoAMD"))
+    {
+        return (void*)entry_vkGetShaderInfoAMD;
+    }
+#endif
+#ifdef VK_NV_external_memory_capabilities
+    if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
+    }
+#endif
+#ifdef VK_NV_external_memory_win32
+    if (!strcmp(name, "vkGetMemoryWin32HandleNV"))
+    {
+        return (void*)entry_vkGetMemoryWin32HandleNV;
+    }
+#endif
+#ifdef VK_NN_vi_surface
+    if (!strcmp(name, "vkCreateViSurfaceNN"))
+    {
+        return (void*)entry_vkCreateViSurfaceNN;
+    }
+#endif
+#ifdef VK_EXT_conditional_rendering
+    if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT"))
+    {
+        return (void*)entry_vkCmdBeginConditionalRenderingEXT;
+    }
+    if (!strcmp(name, "vkCmdEndConditionalRenderingEXT"))
+    {
+        return (void*)entry_vkCmdEndConditionalRenderingEXT;
+    }
+#endif
+#ifdef VK_NVX_device_generated_commands
+    if (!strcmp(name, "vkCmdProcessCommandsNVX"))
+    {
+        return (void*)entry_vkCmdProcessCommandsNVX;
+    }
+    if (!strcmp(name, "vkCmdReserveSpaceForCommandsNVX"))
+    {
+        return (void*)entry_vkCmdReserveSpaceForCommandsNVX;
+    }
+    if (!strcmp(name, "vkCreateIndirectCommandsLayoutNVX"))
+    {
+        return (void*)entry_vkCreateIndirectCommandsLayoutNVX;
+    }
+    if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNVX"))
+    {
+        return (void*)entry_vkDestroyIndirectCommandsLayoutNVX;
+    }
+    if (!strcmp(name, "vkCreateObjectTableNVX"))
+    {
+        return (void*)entry_vkCreateObjectTableNVX;
+    }
+    if (!strcmp(name, "vkDestroyObjectTableNVX"))
+    {
+        return (void*)entry_vkDestroyObjectTableNVX;
+    }
+    if (!strcmp(name, "vkRegisterObjectsNVX"))
+    {
+        return (void*)entry_vkRegisterObjectsNVX;
+    }
+    if (!strcmp(name, "vkUnregisterObjectsNVX"))
+    {
+        return (void*)entry_vkUnregisterObjectsNVX;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+    }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+    if (!strcmp(name, "vkCmdSetViewportWScalingNV"))
+    {
+        return (void*)entry_vkCmdSetViewportWScalingNV;
+    }
+#endif
+#ifdef VK_EXT_direct_mode_display
+    if (!strcmp(name, "vkReleaseDisplayEXT"))
+    {
+        return (void*)entry_vkReleaseDisplayEXT;
+    }
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+    if (!strcmp(name, "vkAcquireXlibDisplayEXT"))
+    {
+        return (void*)entry_vkAcquireXlibDisplayEXT;
+    }
+    if (!strcmp(name, "vkGetRandROutputDisplayEXT"))
+    {
+        return (void*)entry_vkGetRandROutputDisplayEXT;
+    }
+#endif
+#ifdef VK_EXT_display_surface_counter
+    if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+    }
+#endif
+#ifdef VK_EXT_display_control
+    if (!strcmp(name, "vkDisplayPowerControlEXT"))
+    {
+        return (void*)entry_vkDisplayPowerControlEXT;
+    }
+    if (!strcmp(name, "vkRegisterDeviceEventEXT"))
+    {
+        return (void*)entry_vkRegisterDeviceEventEXT;
+    }
+    if (!strcmp(name, "vkRegisterDisplayEventEXT"))
+    {
+        return (void*)entry_vkRegisterDisplayEventEXT;
+    }
+    if (!strcmp(name, "vkGetSwapchainCounterEXT"))
+    {
+        return (void*)entry_vkGetSwapchainCounterEXT;
+    }
+#endif
+#ifdef VK_GOOGLE_display_timing
+    if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE"))
+    {
+        return (void*)entry_vkGetRefreshCycleDurationGOOGLE;
+    }
+    if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE"))
+    {
+        return (void*)entry_vkGetPastPresentationTimingGOOGLE;
+    }
+#endif
+#ifdef VK_EXT_discard_rectangles
+    if (!strcmp(name, "vkCmdSetDiscardRectangleEXT"))
+    {
+        return (void*)entry_vkCmdSetDiscardRectangleEXT;
+    }
+#endif
+#ifdef VK_EXT_hdr_metadata
+    if (!strcmp(name, "vkSetHdrMetadataEXT"))
+    {
+        return (void*)entry_vkSetHdrMetadataEXT;
+    }
+#endif
+#ifdef VK_MVK_ios_surface
+    if (!strcmp(name, "vkCreateIOSSurfaceMVK"))
+    {
+        return (void*)entry_vkCreateIOSSurfaceMVK;
+    }
+#endif
+#ifdef VK_MVK_macos_surface
+    if (!strcmp(name, "vkCreateMacOSSurfaceMVK"))
+    {
+        return (void*)entry_vkCreateMacOSSurfaceMVK;
+    }
+#endif
+#ifdef VK_EXT_debug_utils
+    if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT"))
+    {
+        return (void*)entry_vkSetDebugUtilsObjectNameEXT;
+    }
+    if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT"))
+    {
+        return (void*)entry_vkSetDebugUtilsObjectTagEXT;
+    }
+    if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT"))
+    {
+        return (void*)entry_vkQueueBeginDebugUtilsLabelEXT;
+    }
+    if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT"))
+    {
+        return (void*)entry_vkQueueEndDebugUtilsLabelEXT;
+    }
+    if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT"))
+    {
+        return (void*)entry_vkQueueInsertDebugUtilsLabelEXT;
+    }
+    if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT"))
+    {
+        return (void*)entry_vkCmdBeginDebugUtilsLabelEXT;
+    }
+    if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT"))
+    {
+        return (void*)entry_vkCmdEndDebugUtilsLabelEXT;
+    }
+    if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT"))
+    {
+        return (void*)entry_vkCmdInsertDebugUtilsLabelEXT;
+    }
+    if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT"))
+    {
+        return (void*)entry_vkCreateDebugUtilsMessengerEXT;
+    }
+    if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT"))
+    {
+        return (void*)entry_vkDestroyDebugUtilsMessengerEXT;
+    }
+    if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT"))
+    {
+        return (void*)entry_vkSubmitDebugUtilsMessageEXT;
+    }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+    if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID"))
+    {
+        return (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID;
+    }
+    if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID"))
+    {
+        return (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID;
+    }
+#endif
+#ifdef VK_EXT_sample_locations
+    if (!strcmp(name, "vkCmdSetSampleLocationsEXT"))
+    {
+        return (void*)entry_vkCmdSetSampleLocationsEXT;
+    }
+    if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT"))
+    {
+        return (void*)entry_vkGetPhysicalDeviceMultisamplePropertiesEXT;
+    }
+#endif
+#ifdef VK_EXT_validation_cache
+    if (!strcmp(name, "vkCreateValidationCacheEXT"))
+    {
+        return (void*)entry_vkCreateValidationCacheEXT;
+    }
+    if (!strcmp(name, "vkDestroyValidationCacheEXT"))
+    {
+        return (void*)entry_vkDestroyValidationCacheEXT;
+    }
+    if (!strcmp(name, "vkMergeValidationCachesEXT"))
+    {
+        return (void*)entry_vkMergeValidationCachesEXT;
+    }
+    if (!strcmp(name, "vkGetValidationCacheDataEXT"))
+    {
+        return (void*)entry_vkGetValidationCacheDataEXT;
+    }
+#endif
+#ifdef VK_EXT_external_memory_host
+    if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT"))
+    {
+        return (void*)entry_vkGetMemoryHostPointerPropertiesEXT;
+    }
+#endif
+#ifdef VK_AMD_buffer_marker
+    if (!strcmp(name, "vkCmdWriteBufferMarkerAMD"))
+    {
+        return (void*)entry_vkCmdWriteBufferMarkerAMD;
+    }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+    if (!strcmp(name, "vkCmdSetCheckpointNV"))
+    {
+        return (void*)entry_vkCmdSetCheckpointNV;
+    }
+    if (!strcmp(name, "vkGetQueueCheckpointDataNV"))
+    {
+        return (void*)entry_vkGetQueueCheckpointDataNV;
+    }
+#endif
+    return nullptr;
+}
+
+} // namespace goldfish_vk
diff --git a/system/vulkan/func_table.h b/system/vulkan/func_table.h
new file mode 100644
index 0000000..358eec4
--- /dev/null
+++ b/system/vulkan/func_table.h
@@ -0,0 +1,281 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module func_table
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+#endif
+#ifdef VK_VERSION_1_1
+#endif
+#ifdef VK_KHR_surface
+#endif
+#ifdef VK_KHR_swapchain
+#endif
+#ifdef VK_KHR_display
+#endif
+#ifdef VK_KHR_display_swapchain
+#endif
+#ifdef VK_KHR_xlib_surface
+#endif
+#ifdef VK_KHR_xcb_surface
+#endif
+#ifdef VK_KHR_wayland_surface
+#endif
+#ifdef VK_KHR_mir_surface
+#endif
+#ifdef VK_KHR_android_surface
+#endif
+#ifdef VK_KHR_win32_surface
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+#endif
+#ifdef VK_KHR_external_memory_fd
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+#endif
+#ifdef VK_KHR_push_descriptor
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+#endif
+#ifdef VK_KHR_shared_presentable_image
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+#endif
+#ifdef VK_KHR_external_fence_fd
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+#endif
+#ifdef VK_EXT_debug_report
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+#endif
+#ifdef VK_NVX_device_generated_commands
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+#endif
+#ifdef VK_EXT_display_control
+#endif
+#ifdef VK_GOOGLE_display_timing
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+#endif
+#ifdef VK_MVK_ios_surface
+#endif
+#ifdef VK_MVK_macos_surface
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+#endif
+void* goldfish_vulkan_get_proc_address(const char* name);
+
+} // namespace goldfish_vk
diff --git a/system/vulkan/goldfish_vulkan.cpp b/system/vulkan/goldfish_vulkan.cpp
new file mode 100644
index 0000000..537c966
--- /dev/null
+++ b/system/vulkan/goldfish_vulkan.cpp
@@ -0,0 +1,148 @@
+// Copyright (C) 2018 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 <hardware/hwvulkan.h>
+
+#include <log/log.h>
+
+#include <errno.h>
+#include <string.h>
+
+#include "HostConnection.h"
+#include "ResourceTracker.h"
+#include "VkEncoder.h"
+
+#include "func_table.h"
+
+namespace {
+
+int OpenDevice(const hw_module_t* module, const char* id, hw_device_t** device);
+
+hw_module_methods_t goldfish_vulkan_module_methods = {
+    .open = OpenDevice
+};
+
+extern "C" __attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
+    .common = {
+        .tag = HARDWARE_MODULE_TAG,
+        .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
+        .hal_api_version = HARDWARE_HAL_API_VERSION,
+        .id = HWVULKAN_HARDWARE_MODULE_ID,
+        .name = "Goldfish Vulkan Driver",
+        .author = "The Android Open Source Project",
+        .methods = &goldfish_vulkan_module_methods,
+    },
+};
+
+int CloseDevice(struct hw_device_t* /*device*/) {
+    // nothing to do - opening a device doesn't allocate any resources
+    return 0;
+}
+
+#define VK_HOST_CONNECTION \
+    HostConnection *hostCon = HostConnection::get(); \
+    if (!hostCon) { \
+        ALOGE("vulkan: Failed to get host connection\n"); \
+        return VK_ERROR_DEVICE_LOST; \
+    } \
+    ExtendedRCEncoderContext *rcEnc = hostCon->rcEncoder(); \
+    if (!rcEnc) { \
+        ALOGE("vulkan: Failed to get renderControl encoder context\n"); \
+        return VK_ERROR_DEVICE_LOST; \
+    } \
+    goldfish_vk::VkEncoder *vkEnc = hostCon->vkEncoder(); \
+    if (!vkEnc) { \
+        ALOGE("vulkan: Failed to get Vulkan encoder\n"); \
+        return VK_ERROR_DEVICE_LOST; \
+    } \
+
+VKAPI_ATTR
+VkResult EnumerateInstanceExtensionProperties(
+    const char* layer_name,
+    uint32_t* count,
+    VkExtensionProperties* properties) {
+
+    VK_HOST_CONNECTION;
+
+    if (layer_name) {
+        ALOGW(
+            "Driver vkEnumerateInstanceExtensionProperties shouldn't be called "
+            "with a layer name ('%s')",
+            layer_name);
+    }
+
+    // For now, let's not expose any extensions;
+    // add them one at a time as needed.
+    *count = 0;
+
+    return VK_SUCCESS;
+}
+
+VKAPI_ATTR
+VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+                        const VkAllocationCallbacks* allocator,
+                        VkInstance* out_instance) {
+    ALOGD("%s: goldfish vkCreateInstance\n", __func__);
+    VK_HOST_CONNECTION;
+
+    VkResult res = vkEnc->vkCreateInstance(create_info, nullptr, out_instance);
+
+    return res;
+}
+
+static PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) {
+    if (!strcmp(name, "vkGetDeviceProcAddr")) {
+        return (PFN_vkVoidFunction)(GetDeviceProcAddr);
+    }
+    return (PFN_vkVoidFunction)(goldfish_vk::goldfish_vulkan_get_proc_address(name));
+}
+
+VKAPI_ATTR
+PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
+    (void)instance;
+    if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
+        return (PFN_vkVoidFunction)EnumerateInstanceExtensionProperties;
+    }
+    if (!strcmp(name, "vkCreateInstance")) {
+        return (PFN_vkVoidFunction)CreateInstance;
+    }
+    if (!strcmp(name, "vkGetDeviceProcAddr")) {
+        return (PFN_vkVoidFunction)(GetDeviceProcAddr);
+    }
+    return (PFN_vkVoidFunction)(goldfish_vk::goldfish_vulkan_get_proc_address(name));
+}
+
+hwvulkan_device_t goldfish_vulkan_device = {
+    .common = {
+        .tag = HARDWARE_DEVICE_TAG,
+        .version = HWVULKAN_DEVICE_API_VERSION_0_1,
+        .module = &HAL_MODULE_INFO_SYM.common,
+        .close = CloseDevice,
+    },
+    .EnumerateInstanceExtensionProperties = EnumerateInstanceExtensionProperties,
+    .CreateInstance = CreateInstance,
+    .GetInstanceProcAddr = GetInstanceProcAddr,
+};
+
+int OpenDevice(const hw_module_t* /*module*/,
+               const char* id,
+               hw_device_t** device) {
+    if (strcmp(id, HWVULKAN_DEVICE_0) == 0) {
+        *device = &goldfish_vulkan_device.common;
+        goldfish_vk::ResourceTracker::get();
+        return 0;
+    }
+    return -ENOENT;
+}
+
+} // namespace
diff --git a/system/vulkan_enc/Android.mk b/system/vulkan_enc/Android.mk
new file mode 100644
index 0000000..7a146dc
--- /dev/null
+++ b/system/vulkan_enc/Android.mk
@@ -0,0 +1,64 @@
+
+# Autogenerated makefile
+# android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+# Please do not modify directly;
+# re-run android/scripts/generate-vulkan-sources.sh,
+# or directly from Python by defining:
+# VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+# CEREAL_OUTPUT_DIR: Where to put the generated sources.
+# python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+LOCAL_PATH := $(call my-dir)
+
+$(call emugl-begin-shared-library,libvulkan_enc)
+$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
+$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX) libandroidemu)
+
+# Vulkan include dir
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+LOCAL_C_INCLUDES += \
+    $(LOCAL_PATH) \
+    $(HOST_EMUGL_PATH)/host/include \
+    $(HOST_EMUGL_PATH)/host/include/vulkan
+endif
+
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+LOCAL_C_INCLUDES += \
+    $(LOCAL_PATH) \
+    $(LOCAL_PATH)/../vulkan_enc \
+
+LOCAL_HEADER_LIBRARIES += \
+    vulkan_headers \
+
+endif
+
+LOCAL_CFLAGS += \
+    -DLOG_TAG=\"goldfish_vulkan\" \
+    -DVK_ANDROID_native_buffer \
+    -Wno-missing-field-initializers \
+    -Werror \
+    -fstrict-aliasing \
+    -DVK_USE_PLATFORM_ANDROID_KHR \
+    -DVK_NO_PROTOTYPES \
+
+LOCAL_SRC_FILES := Resources.cpp \
+    Validation.cpp \
+    VulkanStream.cpp \
+    VulkanHandleMapping.cpp \
+    ResourceTracker.cpp \
+    VkEncoder.cpp \
+VkEventHandler.cpp \
+goldfish_vk_extension_structs_guest.cpp \
+goldfish_vk_marshaling_guest.cpp \
+goldfish_vk_deepcopy_guest.cpp \
+goldfish_vk_handlemap_guest.cpp \
+
+
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+$(call emugl-export,SHARED_LIBRARIES,libgui)
+else
+$(call emugl-export,SHARED_LIBRARIES,libsync)
+endif
+
+$(call emugl-end-module)
+
diff --git a/system/vulkan_enc/CMakeLists.txt b/system/vulkan_enc/CMakeLists.txt
new file mode 100644
index 0000000..0f43f29
--- /dev/null
+++ b/system/vulkan_enc/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc/Android.mk" "aad370b1675d05b89d55d471376175c21c2d4567f65a593dabe3038f8806219c")
+set(vulkan_enc_src Resources.cpp Validation.cpp VulkanStream.cpp VulkanHandleMapping.cpp ResourceTracker.cpp VkEncoder.cpp VkEventHandler.cpp goldfish_vk_extension_structs_guest.cpp goldfish_vk_marshaling_guest.cpp goldfish_vk_deepcopy_guest.cpp goldfish_vk_handlemap_guest.cpp)
+android_add_shared_library(vulkan_enc)
+target_include_directories(vulkan_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include/vulkan)
+target_compile_definitions(vulkan_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"goldfish_vulkan\"" "-DVK_ANDROID_native_buffer" "-DVK_USE_PLATFORM_ANDROID_KHR" "-DVK_NO_PROTOTYPES")
+target_compile_options(vulkan_enc PRIVATE "-fvisibility=default" "-Wno-missing-field-initializers" "-Werror" "-fstrict-aliasing")
+target_link_libraries(vulkan_enc PRIVATE gui cutils utils log OpenglCodecCommon_host android-emu-shared)
\ No newline at end of file
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
new file mode 100644
index 0000000..4def37d
--- /dev/null
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -0,0 +1,204 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ResourceTracker.h"
+
+#include "Resources.h"
+
+#include "android/base/synchronization/AndroidLock.h"
+
+#include <unordered_map>
+
+using android::base::guest::AutoLock;
+using android::base::guest::Lock;
+
+namespace goldfish_vk {
+
+#define MAKE_HANDLE_MAPPING_FOREACH(type_name, map_impl, map_to_u64_impl, map_from_u64_impl) \
+    void mapHandles_##type_name(type_name* handles, size_t count) override { \
+        for (size_t i = 0; i < count; ++i) { \
+            map_impl; \
+        } \
+    } \
+    void mapHandles_##type_name##_u64(const type_name* handles, uint64_t* handle_u64s, size_t count) override { \
+        for (size_t i = 0; i < count; ++i) { \
+            map_to_u64_impl; \
+        } \
+    } \
+    void mapHandles_u64_##type_name(const uint64_t* handle_u64s, type_name* handles, size_t count) override { \
+        for (size_t i = 0; i < count; ++i) { \
+            map_from_u64_impl; \
+        } \
+    } \
+
+#define DEFINE_RESOURCE_TRACKING_CLASS(class_name, impl) \
+class class_name : public VulkanHandleMapping { \
+public: \
+    virtual ~class_name() { } \
+    GOLDFISH_VK_LIST_HANDLE_TYPES(impl) \
+}; \
+
+#define CREATE_MAPPING_IMPL_FOR_TYPE(type_name) \
+    MAKE_HANDLE_MAPPING_FOREACH(type_name, \
+        handles[i] = new_from_host_##type_name(handles[i]); ResourceTracker::get()->register_##type_name(handles[i]);, \
+        handle_u64s[i] = (uint64_t)(uintptr_t)new_from_host_##type_name(handles[i]), \
+        handles[i] = (type_name)(uintptr_t)new_from_host_u64_##type_name(handle_u64s[i]); ResourceTracker::get()->register_##type_name(handles[i]);)
+
+#define UNWRAP_MAPPING_IMPL_FOR_TYPE(type_name) \
+    MAKE_HANDLE_MAPPING_FOREACH(type_name, \
+        handles[i] = get_host_##type_name(handles[i]), \
+        handle_u64s[i] = (uint64_t)(uintptr_t)get_host_u64_##type_name(handles[i]), \
+        handles[i] = (type_name)(uintptr_t)get_host_##type_name((type_name)(uintptr_t)handle_u64s[i]))
+
+#define DESTROY_MAPPING_IMPL_FOR_TYPE(type_name) \
+    MAKE_HANDLE_MAPPING_FOREACH(type_name, \
+        ResourceTracker::get()->unregister_##type_name(handles[i]); delete_goldfish_##type_name(handles[i]), \
+        (void)handle_u64s[i]; delete_goldfish_##type_name(handles[i]), \
+        (void)handles[i]; delete_goldfish_##type_name((type_name)(uintptr_t)handle_u64s[i]))
+
+DEFINE_RESOURCE_TRACKING_CLASS(CreateMapping, CREATE_MAPPING_IMPL_FOR_TYPE)
+DEFINE_RESOURCE_TRACKING_CLASS(UnwrapMapping, UNWRAP_MAPPING_IMPL_FOR_TYPE)
+DEFINE_RESOURCE_TRACKING_CLASS(DestroyMapping, DESTROY_MAPPING_IMPL_FOR_TYPE)
+
+class ResourceTracker::Impl {
+public:
+    Impl() = default;
+    CreateMapping createMapping;
+    UnwrapMapping unwrapMapping;
+    DestroyMapping destroyMapping;
+    DefaultHandleMapping defaultMapping;
+
+#define HANDLE_DEFINE_TRIVIAL_INFO_STRUCT(type) \
+    struct type##_Info { \
+        uint32_t unused; \
+    }; \
+
+    GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(HANDLE_DEFINE_TRIVIAL_INFO_STRUCT)
+
+    struct VkDevice_Info {
+        VkPhysicalDevice physdev;
+        VkPhysicalDeviceProperties props;
+        VkPhysicalDeviceMemoryProperties memProps;
+    };
+
+    struct VkDeviceMemory_Info {
+        VkDeviceSize allocationSize;
+        uint32_t memoryTypeIndex;
+    };
+
+#define HANDLE_REGISTER_IMPL_IMPL(type) \
+    std::unordered_map<type, type##_Info> info_##type; \
+    void register_##type(type obj) { \
+        AutoLock lock(mLock); \
+        info_##type[obj] = type##_Info(); \
+    } \
+    void unregister_##type(type obj) { \
+        AutoLock lock(mLock); \
+        info_##type.erase(obj); \
+    } \
+
+    GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_IMPL_IMPL)
+
+    void setDeviceInfo(VkDevice device,
+                       VkPhysicalDevice physdev,
+                       VkPhysicalDeviceProperties props,
+                       VkPhysicalDeviceMemoryProperties memProps) {
+        AutoLock lock(mLock);
+        auto& info = info_VkDevice[device];
+        info.physdev = physdev;
+        info.props = props;
+        info.memProps = memProps;
+    }
+
+    bool isMemoryTypeHostVisible(VkDevice device, uint32_t typeIndex) const {
+        AutoLock lock(mLock);
+        const auto it = info_VkDevice.find(device);
+
+        if (it == info_VkDevice.end()) return false;
+
+        const auto& info = it->second;
+        return info.memProps.memoryTypes[typeIndex].propertyFlags & 
+               VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+    }
+
+    VkDeviceSize getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const {
+        AutoLock lock(mLock);
+        const auto it = info_VkDevice.find(device);
+        if (it == info_VkDevice.end()) return basicSize;
+        const auto& info = it->second;
+
+        VkDeviceSize nonCoherentAtomSize =
+            info.props.limits.nonCoherentAtomSize;
+        VkDeviceSize atoms =
+            (basicSize + nonCoherentAtomSize - 1) / nonCoherentAtomSize;
+        return atoms * nonCoherentAtomSize;
+    }
+
+private:
+    mutable Lock mLock;
+
+};
+ResourceTracker::ResourceTracker() : mImpl(new ResourceTracker::Impl()) { }
+ResourceTracker::~ResourceTracker() { }
+VulkanHandleMapping* ResourceTracker::createMapping() {
+    return &mImpl->createMapping;
+}
+VulkanHandleMapping* ResourceTracker::unwrapMapping() {
+    return &mImpl->unwrapMapping;
+}
+VulkanHandleMapping* ResourceTracker::destroyMapping() {
+    return &mImpl->destroyMapping;
+}
+VulkanHandleMapping* ResourceTracker::defaultMapping() {
+    return &mImpl->defaultMapping;
+}
+static ResourceTracker* sTracker = nullptr;
+// static
+ResourceTracker* ResourceTracker::get() {
+    if (!sTracker) {
+        // To be initialized once on vulkan device open.
+        sTracker = new ResourceTracker;
+    }
+    return sTracker;
+}
+
+#define HANDLE_REGISTER_IMPL(type) \
+    void ResourceTracker::register_##type(type obj) { \
+        mImpl->register_##type(obj); \
+    } \
+    void ResourceTracker::unregister_##type(type obj) { \
+        mImpl->unregister_##type(obj); \
+    } \
+
+GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_IMPL)
+
+void ResourceTracker::setDeviceInfo(
+    VkDevice device,
+    VkPhysicalDevice physdev,
+    VkPhysicalDeviceProperties props,
+    VkPhysicalDeviceMemoryProperties memProps) {
+    mImpl->setDeviceInfo(device, physdev, props, memProps);
+}
+
+bool ResourceTracker::isMemoryTypeHostVisible(
+    VkDevice device, uint32_t typeIndex) const {
+    return mImpl->isMemoryTypeHostVisible(device, typeIndex);
+}
+
+VkDeviceSize ResourceTracker::getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const {
+    return mImpl->getNonCoherentExtendedSize(device, basicSize);
+}
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/ResourceTracker.h b/system/vulkan_enc/ResourceTracker.h
new file mode 100644
index 0000000..e40e413
--- /dev/null
+++ b/system/vulkan_enc/ResourceTracker.h
@@ -0,0 +1,53 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#include "VulkanHandleMapping.h"
+#include "VulkanHandles.h"
+#include "VkEventHandler.h"
+#include <memory>
+
+namespace goldfish_vk {
+
+class ResourceTracker : public VkEventHandler {
+public:
+    ResourceTracker();
+    virtual ~ResourceTracker();
+    static ResourceTracker* get();
+    VulkanHandleMapping* createMapping();
+    VulkanHandleMapping* unwrapMapping();
+    VulkanHandleMapping* destroyMapping();
+    VulkanHandleMapping* defaultMapping();
+
+#define HANDLE_REGISTER_DECL(type) \
+    void register_##type(type); \
+    void unregister_##type(type); \
+
+    GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_DECL)
+
+    void setDeviceInfo(VkDevice device, VkPhysicalDevice physdev, VkPhysicalDeviceProperties props, VkPhysicalDeviceMemoryProperties memProps);
+    bool isMemoryTypeHostVisible(VkDevice device, uint32_t typeIndex) const;
+    VkDeviceSize getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const;
+    bool isValidMemoryRange(
+        VkDevice device,
+        const VkMappedMemoryRange& range) const;
+  private:
+    class Impl;
+    std::unique_ptr<Impl> mImpl;
+};
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/Resources.cpp b/system/vulkan_enc/Resources.cpp
new file mode 100644
index 0000000..c2b972e
--- /dev/null
+++ b/system/vulkan_enc/Resources.cpp
@@ -0,0 +1,338 @@
+// Copyright (C) 2018 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 "Resources.h"
+#include "ResourceTracker.h"
+#include "VkEncoder.h"
+
+#include "gralloc_cb.h"
+#include "goldfish_vk_private_defs.h"
+
+#include "android/base/AlignedBuf.h"
+
+#include <log/log.h>
+#include <stdlib.h>
+#include <sync/sync.h>
+
+using android::aligned_buf_alloc;
+using android::aligned_buf_free;
+
+#define GOLDFISH_VK_OBJECT_DEBUG 0
+
+#if GOLDFISH_VK_OBJECT_DEBUG
+#define D(fmt,...) ALOGD("%s: " fmt, __func__, ##__VA_ARGS__);
+#else
+#ifndef D
+#define D(fmt,...)
+#endif
+#endif
+
+using goldfish_vk::ResourceTracker;
+using goldfish_vk::VkEncoder;
+
+extern "C" {
+
+#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_IMPL(type) \
+    type new_from_host_##type(type underlying) { \
+        struct goldfish_##type* res = \
+            static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
+        if (!res) { \
+            ALOGE("FATAL: Failed to alloc " #type " handle"); \
+            abort(); \
+        } \
+        res->dispatch.magic = HWVULKAN_DISPATCH_MAGIC; \
+        res->underlying = (uint64_t)(uintptr_t)underlying; \
+        return reinterpret_cast<type>(res); \
+    } \
+
+#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL(type) \
+    type new_from_host_##type(type underlying) { \
+        struct goldfish_##type* res = \
+            static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
+        res->underlying = (uint64_t)(uintptr_t)underlying; \
+        return reinterpret_cast<type>(res); \
+    } \
+
+#define GOLDFISH_VK_AS_GOLDFISH_IMPL(type) \
+    struct goldfish_##type* as_goldfish_##type(type toCast) { \
+        return reinterpret_cast<goldfish_##type*>(toCast); \
+    } \
+
+#define GOLDFISH_VK_GET_HOST_IMPL(type) \
+    type get_host_##type(type toUnwrap) { \
+        if (!toUnwrap) return VK_NULL_HANDLE; \
+        auto as_goldfish = as_goldfish_##type(toUnwrap); \
+        return (type)(uintptr_t)(as_goldfish->underlying); \
+    } \
+
+#define GOLDFISH_VK_DELETE_GOLDFISH_IMPL(type) \
+    void delete_goldfish_##type(type toDelete) { \
+        D("guest %p", toDelete); \
+        free(as_goldfish_##type(toDelete)); \
+    } \
+
+#define GOLDFISH_VK_IDENTITY_IMPL(type) \
+    type vk_handle_identity_##type(type handle) { \
+        return handle; \
+    } \
+
+#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_U64_IMPL(type) \
+    type new_from_host_u64_##type(uint64_t underlying) { \
+        struct goldfish_##type* res = \
+            static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
+        if (!res) { \
+            ALOGE("FATAL: Failed to alloc " #type " handle"); \
+            abort(); \
+        } \
+        res->dispatch.magic = HWVULKAN_DISPATCH_MAGIC; \
+        res->underlying = underlying; \
+        return reinterpret_cast<type>(res); \
+    } \
+
+#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL(type) \
+    type new_from_host_u64_##type(uint64_t underlying) { \
+        struct goldfish_##type* res = \
+            static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
+        res->underlying = underlying; \
+        D("guest %p: host u64: 0x%llx", res, (unsigned long long)res->underlying); \
+        return reinterpret_cast<type>(res); \
+    } \
+
+#define GOLDFISH_VK_GET_HOST_U64_IMPL(type) \
+    uint64_t get_host_u64_##type(type toUnwrap) { \
+        if (!toUnwrap) return 0; \
+        auto as_goldfish = as_goldfish_##type(toUnwrap); \
+        D("guest %p: host u64: 0x%llx", toUnwrap, (unsigned long long)as_goldfish->underlying); \
+        return as_goldfish->underlying; \
+    } \
+
+
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DELETE_GOLDFISH_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_U64_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_IMPL)
+
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_IMPL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_IMPL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_IMPL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_IMPL)
+
+GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL)
+GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL)
+GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DELETE_GOLDFISH_IMPL)
+
+// Custom definitions///////////////////////////////////////////////////////////
+
+VkResult goldfish_vkEnumerateInstanceVersion(
+    void*,
+    VkResult,
+    uint32_t* apiVersion) {
+    if (apiVersion) {
+        *apiVersion = VK_MAKE_VERSION(1, 0, 0);
+    }
+    return VK_SUCCESS;
+}
+
+VkResult goldfish_vkEnumerateDeviceExtensionProperties(
+    void*,
+    VkResult,
+    VkPhysicalDevice, const char*,
+    uint32_t *pPropertyCount, VkExtensionProperties *) {
+    *pPropertyCount = 0;
+    return VK_SUCCESS;
+}
+
+void goldfish_vkGetPhysicalDeviceProperties2(
+    void*,
+    VkPhysicalDevice,
+    VkPhysicalDeviceProperties2*)
+{
+    // no-op
+}
+
+VkResult goldfish_vkCreateDevice(
+    void* opaque,
+    VkResult host_return,
+    VkPhysicalDevice physicalDevice,
+    const VkDeviceCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkDevice* pDevice) {
+
+    if (host_return != VK_SUCCESS) return host_return;
+
+    VkEncoder* enc = (VkEncoder*)opaque;
+
+    VkPhysicalDeviceProperties props;
+    VkPhysicalDeviceMemoryProperties memProps;
+    enc->vkGetPhysicalDeviceProperties(physicalDevice, &props);
+    enc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProps);
+
+    ResourceTracker::get()->setDeviceInfo(*pDevice, physicalDevice, props, memProps);
+
+    return host_return;
+}
+
+VkDeviceMemory new_from_host_VkDeviceMemory(VkDeviceMemory mem) {
+    struct goldfish_VkDeviceMemory *res =
+        (struct goldfish_VkDeviceMemory *)malloc(sizeof(goldfish_VkDeviceMemory));
+
+    if (!res) {
+        ALOGE("FATAL: Failed to alloc VkDeviceMemory handle");
+        abort();
+    }
+
+    memset(res, 0x0, sizeof(goldfish_VkDeviceMemory));
+
+    res->underlying = (uint64_t)(uintptr_t)mem;
+
+    return reinterpret_cast<VkDeviceMemory>(res);
+}
+
+VkDeviceMemory new_from_host_u64_VkDeviceMemory(uint64_t mem) {
+    struct goldfish_VkDeviceMemory *res =
+        (struct goldfish_VkDeviceMemory *)malloc(sizeof(goldfish_VkDeviceMemory));
+
+    if (!res) {
+        ALOGE("FATAL: Failed to alloc VkDeviceMemory handle");
+        abort();
+    }
+
+    memset(res, 0x0, sizeof(goldfish_VkDeviceMemory));
+
+    res->underlying = mem;
+
+    return reinterpret_cast<VkDeviceMemory>(res);
+}
+
+void delete_goldfish_VkDeviceMemory(VkDeviceMemory mem) {
+    struct goldfish_VkDeviceMemory* goldfish_mem =
+        as_goldfish_VkDeviceMemory(mem);
+
+    if (!goldfish_mem) return;
+
+    if (goldfish_mem->ptr) {
+        // TODO: unmap the pointer with address space device
+        aligned_buf_free(goldfish_mem->ptr);
+    }
+
+    free(goldfish_mem);
+}
+
+VkResult goldfish_vkAllocateMemory(
+    void*,
+    VkResult host_return,
+    VkDevice device,
+    const VkMemoryAllocateInfo* pAllocateInfo,
+    const VkAllocationCallbacks*,
+    VkDeviceMemory* pMemory) {
+    
+    if (host_return != VK_SUCCESS) return host_return;
+
+    // Assumes pMemory has already been allocated.
+    goldfish_VkDeviceMemory* mem = as_goldfish_VkDeviceMemory(*pMemory);
+    VkDeviceSize size = pAllocateInfo->allocationSize;
+
+    // assume memory is not host visible.
+    mem->ptr = nullptr;
+    mem->size = size;
+    mem->mappedSize = ResourceTracker::get()->getNonCoherentExtendedSize(device, size);
+
+    if (!ResourceTracker::get()->isMemoryTypeHostVisible(device, pAllocateInfo->memoryTypeIndex)) {
+        return host_return;
+    }
+
+    // This is a strict alignment; we do not expect any
+    // actual device to have more stringent requirements
+    // than this.
+    mem->ptr = (uint8_t*)aligned_buf_alloc(4096, mem->mappedSize);
+    D("host visible alloc: size 0x%llx host ptr %p mapped size 0x%llx",
+      (unsigned long long)size, mem->ptr,
+      (unsigned long long)mem->mappedSize);
+
+    return host_return;
+}
+
+VkResult goldfish_vkMapMemory(
+    void*,
+    VkResult host_result,
+    VkDevice,
+    VkDeviceMemory memory,
+    VkDeviceSize offset,
+    VkDeviceSize size,
+    VkMemoryMapFlags,
+    void** ppData) {
+    
+    if (host_result != VK_SUCCESS) return host_result;
+
+    goldfish_VkDeviceMemory* mem = as_goldfish_VkDeviceMemory(memory);
+
+    if (!mem->ptr) {
+        return VK_ERROR_MEMORY_MAP_FAILED;
+    }
+
+    if (size != VK_WHOLE_SIZE &&
+        (mem->ptr + offset + size > mem->ptr + mem->size)) {
+        return VK_ERROR_MEMORY_MAP_FAILED;
+    }
+
+    *ppData = mem->ptr + offset;
+
+    return host_result;
+}
+
+void goldfish_vkUnmapMemory(
+    void*,
+    VkDevice,
+    VkDeviceMemory) {
+    // no-op
+}
+
+void goldfish_unwrap_VkNativeBufferANDROID(
+    const VkImageCreateInfo* pCreateInfo,
+    VkImageCreateInfo* local_pCreateInfo) {
+
+    if (!pCreateInfo->pNext) return;
+
+    const VkNativeBufferANDROID* nativeInfo =
+        reinterpret_cast<const VkNativeBufferANDROID*>(pCreateInfo->pNext);
+
+    if (VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID != nativeInfo->sType) {
+        return;
+    }
+
+    const cb_handle_t* cb_handle =
+        reinterpret_cast<const cb_handle_t*>(nativeInfo->handle);
+
+    if (!cb_handle) return;
+
+    VkNativeBufferANDROID* nativeInfoOut =
+        reinterpret_cast<VkNativeBufferANDROID*>(local_pCreateInfo);
+
+    if (!nativeInfoOut->handle) {
+        ALOGE("FATAL: Local native buffer info not properly allocated!");
+        abort();
+    }
+
+    *(uint32_t*)(nativeInfoOut->handle) = cb_handle->hostHandle;
+}
+
+void goldfish_unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int*) {
+    if (fd != -1) {
+        sync_wait(fd, 3000);
+    }
+}
+
+} // extern "C"
diff --git a/system/vulkan_enc/Resources.h b/system/vulkan_enc/Resources.h
new file mode 100644
index 0000000..37cd882
--- /dev/null
+++ b/system/vulkan_enc/Resources.h
@@ -0,0 +1,138 @@
+// Copyright (C) 2018 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.
+#pragma once
+
+#include <hardware/hwvulkan.h>
+#include <vulkan/vulkan.h>
+
+#include "VulkanHandles.h"
+
+#include <inttypes.h>
+
+extern "C" {
+
+#define GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT(type) \
+    struct goldfish_##type { \
+        hwvulkan_dispatch_t dispatch; \
+        uint64_t underlying; \
+    }; \
+
+#define GOLDFISH_VK_DEFINE_TRIVIAL_NON_DISPATCHABLE_HANDLE_STRUCT(type) \
+    struct goldfish_##type { \
+        uint64_t underlying; \
+    }; \
+
+#define GOLDFISH_VK_NEW_FROM_HOST_DECL(type) \
+    type new_from_host_##type(type);
+
+#define GOLDFISH_VK_AS_GOLDFISH_DECL(type) \
+    struct goldfish_##type* as_goldfish_##type(type);
+
+#define GOLDFISH_VK_GET_HOST_DECL(type) \
+    type get_host_##type(type);
+
+#define GOLDFISH_VK_DELETE_GOLDFISH_DECL(type) \
+    void delete_goldfish_##type(type);
+
+#define GOLDFISH_VK_IDENTITY_DECL(type) \
+    type vk_handle_identity_##type(type);
+
+#define GOLDFISH_VK_NEW_FROM_HOST_U64_DECL(type) \
+    type new_from_host_u64_##type(uint64_t);
+
+#define GOLDFISH_VK_GET_HOST_U64_DECL(type) \
+    uint64_t get_host_u64_##type(type);
+
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_DECL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_DECL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_DECL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DELETE_GOLDFISH_DECL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_DECL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_U64_DECL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_DECL)
+
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DELETE_GOLDFISH_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_U64_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_DECL)
+
+GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DEFINE_TRIVIAL_NON_DISPATCHABLE_HANDLE_STRUCT)
+
+// Custom definitions///////////////////////////////////////////////////////////
+
+VkResult goldfish_vkEnumerateInstanceVersion(
+    void* opaque,
+    VkResult host_return,
+    uint32_t* apiVersion);
+
+VkResult goldfish_vkEnumerateDeviceExtensionProperties(
+    void* opaque,
+    VkResult host_return,
+    VkPhysicalDevice physicalDevice, const char *pLayerName,
+    uint32_t *pPropertyCount, VkExtensionProperties *pProperties);
+
+void goldfish_vkGetPhysicalDeviceProperties2(
+    void* opaque,
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceProperties2* pProperties);
+
+VkResult goldfish_vkCreateDevice(
+    void* opaque,
+    VkResult host_return,
+    VkPhysicalDevice physicalDevice,
+    const VkDeviceCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDevice* pDevice);
+
+struct goldfish_VkDeviceMemory {
+    uint64_t underlying;
+    uint8_t* ptr;
+    VkDeviceSize size;
+    VkDeviceSize mappedSize;
+};
+
+VkResult goldfish_vkAllocateMemory(
+    void* opaque,
+    VkResult host_return,
+    VkDevice device,
+    const VkMemoryAllocateInfo* pAllocateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDeviceMemory* pMemory);
+
+VkResult goldfish_vkMapMemory(
+    void* opaque,
+    VkResult host_return,
+    VkDevice device,
+    VkDeviceMemory memory,
+    VkDeviceSize offset,
+    VkDeviceSize size,
+    VkMemoryMapFlags flags,
+    void** ppData);
+
+void goldfish_vkUnmapMemory(
+    void* opaque,
+    VkDevice device,
+    VkDeviceMemory memory);
+
+void goldfish_unwrap_VkNativeBufferANDROID(
+    const VkImageCreateInfo* pCreateInfo,
+    VkImageCreateInfo* local_pCreateInfo);
+
+void goldfish_unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int* fd_out);
+
+} // extern "C"
diff --git a/system/vulkan_enc/Validation.cpp b/system/vulkan_enc/Validation.cpp
new file mode 100644
index 0000000..7653f76
--- /dev/null
+++ b/system/vulkan_enc/Validation.cpp
@@ -0,0 +1,70 @@
+// Copyright (C) 2018 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 "Validation.h"
+
+#include "Resources.h"
+
+namespace goldfish_vk {
+
+static bool is_range_good(const VkMappedMemoryRange& range) {
+    const goldfish_VkDeviceMemory* mem =
+        as_goldfish_VkDeviceMemory(range.memory);
+
+    if (!mem || !mem->ptr) {
+        return false;
+    }
+
+    VkDeviceSize offset = range.offset;
+    VkDeviceSize size = range.size;
+
+    if (size == VK_WHOLE_SIZE) {
+        return offset <= mem->mappedSize;
+    };
+
+    return offset + size <= mem->mappedSize;
+}
+
+VkResult Validation::on_vkFlushMappedMemoryRanges(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t memoryRangeCount,
+    const VkMappedMemoryRange* pMemoryRanges) {
+
+    for (uint32_t i = 0; i < memoryRangeCount; ++i) {
+        if (!is_range_good(pMemoryRanges[i])) {
+            return VK_ERROR_OUT_OF_HOST_MEMORY;
+        }
+    }
+
+    return VK_SUCCESS;
+}
+
+VkResult Validation::on_vkInvalidateMappedMemoryRanges(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t memoryRangeCount,
+    const VkMappedMemoryRange* pMemoryRanges) {
+
+    for (uint32_t i = 0; i < memoryRangeCount; ++i) {
+        if (!is_range_good(pMemoryRanges[i])) {
+            return VK_ERROR_OUT_OF_HOST_MEMORY;
+        }
+    }
+
+    return VK_SUCCESS;
+}
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/Validation.h b/system/vulkan_enc/Validation.h
new file mode 100644
index 0000000..30af8b4
--- /dev/null
+++ b/system/vulkan_enc/Validation.h
@@ -0,0 +1,38 @@
+// Copyright (C) 2018 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.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#include "VkEventHandler.h"
+
+namespace goldfish_vk {
+
+class Validation : public VkEventHandler {
+public:
+    VkResult on_vkFlushMappedMemoryRanges(
+        void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t memoryRangeCount,
+        const VkMappedMemoryRange* pMemoryRanges) override;
+    VkResult on_vkInvalidateMappedMemoryRanges(
+        void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t memoryRangeCount,
+        const VkMappedMemoryRange* pMemoryRanges) override;
+};
+
+} // namespace goldfish_vk
\ No newline at end of file
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
new file mode 100644
index 0000000..87745f4
--- /dev/null
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -0,0 +1,18960 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module VkEncoder
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "VkEncoder.h"
+
+
+#include "IOStream.h"
+#include "Resources.h"
+#include "ResourceTracker.h"
+#include "Validation.h"
+#include "VulkanStream.h"
+
+#include "android/base/AlignedBuf.h"
+#include "android/base/Pool.h"
+
+#include "goldfish_vk_marshaling_guest.h"
+#include "goldfish_vk_deepcopy_guest.h"
+#include "goldfish_vk_handlemap_guest.h"
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+
+
+using namespace goldfish_vk;
+
+using android::aligned_buf_alloc;
+using android::aligned_buf_free;
+using android::base::Pool;
+
+class VkEncoder::Impl {
+public:
+    Impl(IOStream* stream) : m_stream(stream) { }
+    VulkanCountingStream* countingStream() { return &m_countingStream; }
+    VulkanStream* stream() { return &m_stream; }
+    Pool* pool() { return &m_pool; }
+    ResourceTracker* resources() { return ResourceTracker::get(); }
+    Validation* validation() { return &m_validation; }
+private:
+    VulkanCountingStream m_countingStream;
+    VulkanStream m_stream;
+    Pool m_pool { 8, 4096, 64 };
+
+    Validation m_validation;
+};
+
+VkEncoder::VkEncoder(IOStream *stream) :
+    mImpl(new VkEncoder::Impl(stream)) { }
+
+#define VALIDATE_RET(retType, success, validate) \
+    retType goldfish_vk_validateResult = validate; \
+    if (goldfish_vk_validateResult != success) return goldfish_vk_validateResult; \
+
+#define VALIDATE_VOID(validate) \
+    VkResult goldfish_vk_validateResult = validate; \
+    if (goldfish_vk_validateResult != VK_SUCCESS) return; \
+
+#ifdef VK_VERSION_1_0
+VkResult VkEncoder::vkCreateInstance(
+    const VkInstanceCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkInstance* pInstance)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstanceCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkInstanceCreateInfo*)pool->alloc(sizeof(const VkInstanceCreateInfo));
+        deepcopy_VkInstanceCreateInfo(pool, pCreateInfo, (VkInstanceCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        marshal_VkInstanceCreateInfo(countingStream, (VkInstanceCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_0 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_0);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(pInstance, &cgen_var_1, 1);
+        countingStream->write((uint64_t*)&cgen_var_1, 8);
+    }
+    uint32_t packetSize_vkCreateInstance = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateInstance = OP_vkCreateInstance;
+    stream->write(&opcode_vkCreateInstance, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateInstance, sizeof(uint32_t));
+    marshal_VkInstanceCreateInfo(stream, (VkInstanceCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_2);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_3;
+    stream->handleMapping()->mapHandles_VkInstance_u64(pInstance, &cgen_var_3, 1);
+    stream->write((uint64_t*)&cgen_var_3, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_4;
+    stream->read((uint64_t*)&cgen_var_4, 8);
+    stream->handleMapping()->mapHandles_u64_VkInstance(&cgen_var_4, (VkInstance*)pInstance, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateInstance_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateInstance_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateInstance_VkResult_return;
+}
+
+void VkEncoder::vkDestroyInstance(
+    VkInstance instance,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_5;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_5, 1);
+        countingStream->write((uint64_t*)&cgen_var_5, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_6 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_6);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyInstance = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyInstance = OP_vkDestroyInstance;
+    stream->write(&opcode_vkDestroyInstance, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyInstance, sizeof(uint32_t));
+    uint64_t cgen_var_7;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_7, 1);
+    stream->write((uint64_t*)&cgen_var_7, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_8 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_8);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkInstance((VkInstance*)&instance);
+}
+
+VkResult VkEncoder::vkEnumeratePhysicalDevices(
+    VkInstance instance,
+    uint32_t* pPhysicalDeviceCount,
+    VkPhysicalDevice* pPhysicalDevices)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    local_instance = instance;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_9;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_9, 1);
+        countingStream->write((uint64_t*)&cgen_var_9, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_10 = (uint64_t)(uintptr_t)pPhysicalDeviceCount;
+        countingStream->putBe64(cgen_var_10);
+        if (pPhysicalDeviceCount)
+        {
+            countingStream->write((uint32_t*)pPhysicalDeviceCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_11 = (uint64_t)(uintptr_t)pPhysicalDevices;
+        countingStream->putBe64(cgen_var_11);
+        if (pPhysicalDevices)
+        {
+            if ((*(pPhysicalDeviceCount)))
+            {
+                uint64_t* cgen_var_12;
+                countingStream->alloc((void**)&cgen_var_12, (*(pPhysicalDeviceCount)) * 8);
+                countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(pPhysicalDevices, cgen_var_12, (*(pPhysicalDeviceCount)));
+                countingStream->write((uint64_t*)cgen_var_12, (*(pPhysicalDeviceCount)) * 8);
+            }
+        }
+    }
+    uint32_t packetSize_vkEnumeratePhysicalDevices = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkEnumeratePhysicalDevices = OP_vkEnumeratePhysicalDevices;
+    stream->write(&opcode_vkEnumeratePhysicalDevices, sizeof(uint32_t));
+    stream->write(&packetSize_vkEnumeratePhysicalDevices, sizeof(uint32_t));
+    uint64_t cgen_var_13;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_13, 1);
+    stream->write((uint64_t*)&cgen_var_13, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_14 = (uint64_t)(uintptr_t)pPhysicalDeviceCount;
+    stream->putBe64(cgen_var_14);
+    if (pPhysicalDeviceCount)
+    {
+        stream->write((uint32_t*)pPhysicalDeviceCount, sizeof(uint32_t));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    // WARNING PTR CHECK
+    uint64_t cgen_var_15 = (uint64_t)(uintptr_t)pPhysicalDevices;
+    stream->putBe64(cgen_var_15);
+    if (pPhysicalDevices)
+    {
+        if ((*(pPhysicalDeviceCount)))
+        {
+            uint64_t* cgen_var_16;
+            stream->alloc((void**)&cgen_var_16, (*(pPhysicalDeviceCount)) * 8);
+            stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(pPhysicalDevices, cgen_var_16, (*(pPhysicalDeviceCount)));
+            stream->write((uint64_t*)cgen_var_16, (*(pPhysicalDeviceCount)) * 8);
+        }
+    }
+    stream->setHandleMapping(resources->unwrapMapping());
+    // WARNING PTR CHECK
+    uint32_t* check_pPhysicalDeviceCount;
+    check_pPhysicalDeviceCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPhysicalDeviceCount)
+    {
+        if (!(check_pPhysicalDeviceCount))
+        {
+            fprintf(stderr, "fatal: pPhysicalDeviceCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPhysicalDeviceCount, sizeof(uint32_t));
+    }
+    stream->setHandleMapping(resources->createMapping());
+    // WARNING PTR CHECK
+    VkPhysicalDevice* check_pPhysicalDevices;
+    check_pPhysicalDevices = (VkPhysicalDevice*)(uintptr_t)stream->getBe64();
+    if (pPhysicalDevices)
+    {
+        if (!(check_pPhysicalDevices))
+        {
+            fprintf(stderr, "fatal: pPhysicalDevices inconsistent between guest and host\n");
+        }
+        if ((*(pPhysicalDeviceCount)))
+        {
+            uint64_t* cgen_var_19;
+            stream->alloc((void**)&cgen_var_19, (*(pPhysicalDeviceCount)) * 8);
+            stream->read((uint64_t*)cgen_var_19, (*(pPhysicalDeviceCount)) * 8);
+            stream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_19, (VkPhysicalDevice*)pPhysicalDevices, (*(pPhysicalDeviceCount)));
+        }
+    }
+    stream->unsetHandleMapping();
+    VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
+    stream->read(&vkEnumeratePhysicalDevices_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkEnumeratePhysicalDevices_VkResult_return;
+}
+
+void VkEncoder::vkGetPhysicalDeviceFeatures(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceFeatures* pFeatures)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_20;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_20, 1);
+        countingStream->write((uint64_t*)&cgen_var_20, 1 * 8);
+        marshal_VkPhysicalDeviceFeatures(countingStream, (VkPhysicalDeviceFeatures*)(pFeatures));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceFeatures = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceFeatures = OP_vkGetPhysicalDeviceFeatures;
+    stream->write(&opcode_vkGetPhysicalDeviceFeatures, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceFeatures, sizeof(uint32_t));
+    uint64_t cgen_var_21;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_21, 1);
+    stream->write((uint64_t*)&cgen_var_21, 1 * 8);
+    marshal_VkPhysicalDeviceFeatures(stream, (VkPhysicalDeviceFeatures*)(pFeatures));
+    unmarshal_VkPhysicalDeviceFeatures(stream, (VkPhysicalDeviceFeatures*)(pFeatures));
+}
+
+void VkEncoder::vkGetPhysicalDeviceFormatProperties(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkFormatProperties* pFormatProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkFormat local_format;
+    local_physicalDevice = physicalDevice;
+    local_format = format;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_22;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_22, 1);
+        countingStream->write((uint64_t*)&cgen_var_22, 1 * 8);
+        countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+        marshal_VkFormatProperties(countingStream, (VkFormatProperties*)(pFormatProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceFormatProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceFormatProperties = OP_vkGetPhysicalDeviceFormatProperties;
+    stream->write(&opcode_vkGetPhysicalDeviceFormatProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceFormatProperties, sizeof(uint32_t));
+    uint64_t cgen_var_23;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_23, 1);
+    stream->write((uint64_t*)&cgen_var_23, 1 * 8);
+    stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+    marshal_VkFormatProperties(stream, (VkFormatProperties*)(pFormatProperties));
+    unmarshal_VkFormatProperties(stream, (VkFormatProperties*)(pFormatProperties));
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkImageType type,
+    VkImageTiling tiling,
+    VkImageUsageFlags usage,
+    VkImageCreateFlags flags,
+    VkImageFormatProperties* pImageFormatProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkFormat local_format;
+    VkImageType local_type;
+    VkImageTiling local_tiling;
+    VkImageUsageFlags local_usage;
+    VkImageCreateFlags local_flags;
+    local_physicalDevice = physicalDevice;
+    local_format = format;
+    local_type = type;
+    local_tiling = tiling;
+    local_usage = usage;
+    local_flags = flags;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_24;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_24, 1);
+        countingStream->write((uint64_t*)&cgen_var_24, 1 * 8);
+        countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+        countingStream->write((VkImageType*)&local_type, sizeof(VkImageType));
+        countingStream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+        countingStream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+        countingStream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
+        marshal_VkImageFormatProperties(countingStream, (VkImageFormatProperties*)(pImageFormatProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties = OP_vkGetPhysicalDeviceImageFormatProperties;
+    stream->write(&opcode_vkGetPhysicalDeviceImageFormatProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceImageFormatProperties, sizeof(uint32_t));
+    uint64_t cgen_var_25;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_25, 1);
+    stream->write((uint64_t*)&cgen_var_25, 1 * 8);
+    stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+    stream->write((VkImageType*)&local_type, sizeof(VkImageType));
+    stream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+    stream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+    stream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
+    marshal_VkImageFormatProperties(stream, (VkImageFormatProperties*)(pImageFormatProperties));
+    unmarshal_VkImageFormatProperties(stream, (VkImageFormatProperties*)(pImageFormatProperties));
+    VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceImageFormatProperties_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
+}
+
+void VkEncoder::vkGetPhysicalDeviceProperties(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceProperties* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_26;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_26, 1);
+        countingStream->write((uint64_t*)&cgen_var_26, 1 * 8);
+        marshal_VkPhysicalDeviceProperties(countingStream, (VkPhysicalDeviceProperties*)(pProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceProperties = OP_vkGetPhysicalDeviceProperties;
+    stream->write(&opcode_vkGetPhysicalDeviceProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceProperties, sizeof(uint32_t));
+    uint64_t cgen_var_27;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_27, 1);
+    stream->write((uint64_t*)&cgen_var_27, 1 * 8);
+    marshal_VkPhysicalDeviceProperties(stream, (VkPhysicalDeviceProperties*)(pProperties));
+    unmarshal_VkPhysicalDeviceProperties(stream, (VkPhysicalDeviceProperties*)(pProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_28;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_28, 1);
+        countingStream->write((uint64_t*)&cgen_var_28, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_29 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+        countingStream->putBe64(cgen_var_29);
+        if (pQueueFamilyPropertyCount)
+        {
+            countingStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_30 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+        countingStream->putBe64(cgen_var_30);
+        if (pQueueFamilyProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+            {
+                marshal_VkQueueFamilyProperties(countingStream, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties = OP_vkGetPhysicalDeviceQueueFamilyProperties;
+    stream->write(&opcode_vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t));
+    uint64_t cgen_var_31;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_31, 1);
+    stream->write((uint64_t*)&cgen_var_31, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_32 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+    stream->putBe64(cgen_var_32);
+    if (pQueueFamilyPropertyCount)
+    {
+        stream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_33 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+    stream->putBe64(cgen_var_33);
+    if (pQueueFamilyProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+        {
+            marshal_VkQueueFamilyProperties(stream, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pQueueFamilyPropertyCount;
+    check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pQueueFamilyPropertyCount)
+    {
+        if (!(check_pQueueFamilyPropertyCount))
+        {
+            fprintf(stderr, "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkQueueFamilyProperties* check_pQueueFamilyProperties;
+    check_pQueueFamilyProperties = (VkQueueFamilyProperties*)(uintptr_t)stream->getBe64();
+    if (pQueueFamilyProperties)
+    {
+        if (!(check_pQueueFamilyProperties))
+        {
+            fprintf(stderr, "fatal: pQueueFamilyProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+        {
+            unmarshal_VkQueueFamilyProperties(stream, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
+        }
+    }
+}
+
+void VkEncoder::vkGetPhysicalDeviceMemoryProperties(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_36;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_36, 1);
+        countingStream->write((uint64_t*)&cgen_var_36, 1 * 8);
+        marshal_VkPhysicalDeviceMemoryProperties(countingStream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceMemoryProperties = OP_vkGetPhysicalDeviceMemoryProperties;
+    stream->write(&opcode_vkGetPhysicalDeviceMemoryProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceMemoryProperties, sizeof(uint32_t));
+    uint64_t cgen_var_37;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_37, 1);
+    stream->write((uint64_t*)&cgen_var_37, 1 * 8);
+    marshal_VkPhysicalDeviceMemoryProperties(stream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
+    unmarshal_VkPhysicalDeviceMemoryProperties(stream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
+}
+
+PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr(
+    VkInstance instance,
+    const char* pName)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    char* local_pName;
+    local_instance = instance;
+    local_pName = nullptr;
+    if (pName)
+    {
+        local_pName = pool->strDup(pName);
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_38;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_38, 1);
+        countingStream->write((uint64_t*)&cgen_var_38, 1 * 8);
+        countingStream->putString(local_pName);
+    }
+    uint32_t packetSize_vkGetInstanceProcAddr = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetInstanceProcAddr = OP_vkGetInstanceProcAddr;
+    stream->write(&opcode_vkGetInstanceProcAddr, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetInstanceProcAddr, sizeof(uint32_t));
+    uint64_t cgen_var_39;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_39, 1);
+    stream->write((uint64_t*)&cgen_var_39, 1 * 8);
+    stream->putString(local_pName);
+    PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+    stream->read(&vkGetInstanceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
+}
+
+PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr(
+    VkDevice device,
+    const char* pName)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    char* local_pName;
+    local_device = device;
+    local_pName = nullptr;
+    if (pName)
+    {
+        local_pName = pool->strDup(pName);
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_40;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_40, 1);
+        countingStream->write((uint64_t*)&cgen_var_40, 1 * 8);
+        countingStream->putString(local_pName);
+    }
+    uint32_t packetSize_vkGetDeviceProcAddr = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDeviceProcAddr = OP_vkGetDeviceProcAddr;
+    stream->write(&opcode_vkGetDeviceProcAddr, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDeviceProcAddr, sizeof(uint32_t));
+    uint64_t cgen_var_41;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_41, 1);
+    stream->write((uint64_t*)&cgen_var_41, 1 * 8);
+    stream->putString(local_pName);
+    PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+    stream->read(&vkGetDeviceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
+}
+
+VkResult VkEncoder::vkCreateDevice(
+    VkPhysicalDevice physicalDevice,
+    const VkDeviceCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDevice* pDevice)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkDeviceCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_physicalDevice = physicalDevice;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDeviceCreateInfo*)pool->alloc(sizeof(const VkDeviceCreateInfo));
+        deepcopy_VkDeviceCreateInfo(pool, pCreateInfo, (VkDeviceCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_42;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_42, 1);
+        countingStream->write((uint64_t*)&cgen_var_42, 1 * 8);
+        marshal_VkDeviceCreateInfo(countingStream, (VkDeviceCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_43 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_43);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_44;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(pDevice, &cgen_var_44, 1);
+        countingStream->write((uint64_t*)&cgen_var_44, 8);
+    }
+    uint32_t packetSize_vkCreateDevice = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateDevice = OP_vkCreateDevice;
+    stream->write(&opcode_vkCreateDevice, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateDevice, sizeof(uint32_t));
+    uint64_t cgen_var_45;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_45, 1);
+    stream->write((uint64_t*)&cgen_var_45, 1 * 8);
+    marshal_VkDeviceCreateInfo(stream, (VkDeviceCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_46 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_46);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_47;
+    stream->handleMapping()->mapHandles_VkDevice_u64(pDevice, &cgen_var_47, 1);
+    stream->write((uint64_t*)&cgen_var_47, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_48;
+    stream->read((uint64_t*)&cgen_var_48, 8);
+    stream->handleMapping()->mapHandles_u64_VkDevice(&cgen_var_48, (VkDevice*)pDevice, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateDevice_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateDevice_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    goldfish_vkCreateDevice(this, vkCreateDevice_VkResult_return, physicalDevice, pCreateInfo, pAllocator, pDevice);
+    return vkCreateDevice_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDevice(
+    VkDevice device,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_49;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_49, 1);
+        countingStream->write((uint64_t*)&cgen_var_49, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_50 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_50);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyDevice = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyDevice = OP_vkDestroyDevice;
+    stream->write(&opcode_vkDestroyDevice, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyDevice, sizeof(uint32_t));
+    uint64_t cgen_var_51;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_51, 1);
+    stream->write((uint64_t*)&cgen_var_51, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_52 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_52);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkDevice((VkDevice*)&device);
+}
+
+VkResult VkEncoder::vkEnumerateInstanceExtensionProperties(
+    const char* pLayerName,
+    uint32_t* pPropertyCount,
+    VkExtensionProperties* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    char* local_pLayerName;
+    local_pLayerName = nullptr;
+    if (pLayerName)
+    {
+        local_pLayerName = pool->strDup(pLayerName);
+    }
+    countingStream->rewind();
+    {
+        countingStream->putString(local_pLayerName);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_53 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_53);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_54 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_54);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkExtensionProperties(countingStream, (VkExtensionProperties*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkEnumerateInstanceExtensionProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkEnumerateInstanceExtensionProperties = OP_vkEnumerateInstanceExtensionProperties;
+    stream->write(&opcode_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t));
+    stream->putString(local_pLayerName);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_55 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_55);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_56 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_56);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkExtensionProperties* check_pProperties;
+    check_pProperties = (VkExtensionProperties*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i));
+        }
+    }
+    VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
+    stream->read(&vkEnumerateInstanceExtensionProperties_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkEnumerateInstanceExtensionProperties_VkResult_return;
+}
+
+VkResult VkEncoder::vkEnumerateDeviceExtensionProperties(
+    VkPhysicalDevice physicalDevice,
+    const char* pLayerName,
+    uint32_t* pPropertyCount,
+    VkExtensionProperties* pProperties)
+{
+    VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
+    vkEnumerateDeviceExtensionProperties_VkResult_return = goldfish_vkEnumerateDeviceExtensionProperties(this, vkEnumerateDeviceExtensionProperties_VkResult_return, physicalDevice, pLayerName, pPropertyCount, pProperties);
+    return vkEnumerateDeviceExtensionProperties_VkResult_return;
+}
+
+VkResult VkEncoder::vkEnumerateInstanceLayerProperties(
+    uint32_t* pPropertyCount,
+    VkLayerProperties* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    countingStream->rewind();
+    {
+        // WARNING PTR CHECK
+        uint64_t cgen_var_59 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_59);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_60 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_60);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkLayerProperties(countingStream, (VkLayerProperties*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkEnumerateInstanceLayerProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkEnumerateInstanceLayerProperties = OP_vkEnumerateInstanceLayerProperties;
+    stream->write(&opcode_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_61 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_61);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_62 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_62);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkLayerProperties* check_pProperties;
+    check_pProperties = (VkLayerProperties*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
+        }
+    }
+    VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
+    stream->read(&vkEnumerateInstanceLayerProperties_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkEnumerateInstanceLayerProperties_VkResult_return;
+}
+
+VkResult VkEncoder::vkEnumerateDeviceLayerProperties(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pPropertyCount,
+    VkLayerProperties* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_65;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_65, 1);
+        countingStream->write((uint64_t*)&cgen_var_65, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_66 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_66);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_67 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_67);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkLayerProperties(countingStream, (VkLayerProperties*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkEnumerateDeviceLayerProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkEnumerateDeviceLayerProperties = OP_vkEnumerateDeviceLayerProperties;
+    stream->write(&opcode_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
+    uint64_t cgen_var_68;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_68, 1);
+    stream->write((uint64_t*)&cgen_var_68, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_69 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_69);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_70 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_70);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkLayerProperties* check_pProperties;
+    check_pProperties = (VkLayerProperties*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
+        }
+    }
+    VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
+    stream->read(&vkEnumerateDeviceLayerProperties_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkEnumerateDeviceLayerProperties_VkResult_return;
+}
+
+void VkEncoder::vkGetDeviceQueue(
+    VkDevice device,
+    uint32_t queueFamilyIndex,
+    uint32_t queueIndex,
+    VkQueue* pQueue)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_queueFamilyIndex;
+    uint32_t local_queueIndex;
+    local_device = device;
+    local_queueFamilyIndex = queueFamilyIndex;
+    local_queueIndex = queueIndex;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_73;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_73, 1);
+        countingStream->write((uint64_t*)&cgen_var_73, 1 * 8);
+        countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_queueIndex, sizeof(uint32_t));
+        uint64_t cgen_var_74;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_74, 1);
+        countingStream->write((uint64_t*)&cgen_var_74, 8);
+    }
+    uint32_t packetSize_vkGetDeviceQueue = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDeviceQueue = OP_vkGetDeviceQueue;
+    stream->write(&opcode_vkGetDeviceQueue, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDeviceQueue, sizeof(uint32_t));
+    uint64_t cgen_var_75;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_75, 1);
+    stream->write((uint64_t*)&cgen_var_75, 1 * 8);
+    stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_queueIndex, sizeof(uint32_t));
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_76;
+    stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_76, 1);
+    stream->write((uint64_t*)&cgen_var_76, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_77;
+    stream->read((uint64_t*)&cgen_var_77, 8);
+    stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_77, (VkQueue*)pQueue, 1);
+    stream->unsetHandleMapping();
+}
+
+VkResult VkEncoder::vkQueueSubmit(
+    VkQueue queue,
+    uint32_t submitCount,
+    const VkSubmitInfo* pSubmits,
+    VkFence fence)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkQueue local_queue;
+    uint32_t local_submitCount;
+    VkSubmitInfo* local_pSubmits;
+    VkFence local_fence;
+    local_queue = queue;
+    local_submitCount = submitCount;
+    local_pSubmits = nullptr;
+    if (pSubmits)
+    {
+        local_pSubmits = (VkSubmitInfo*)pool->alloc(((submitCount)) * sizeof(const VkSubmitInfo));
+        for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
+        {
+            deepcopy_VkSubmitInfo(pool, pSubmits + i, (VkSubmitInfo*)(local_pSubmits + i));
+        }
+    }
+    local_fence = fence;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_78;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_78, 1);
+        countingStream->write((uint64_t*)&cgen_var_78, 1 * 8);
+        countingStream->write((uint32_t*)&local_submitCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
+        {
+            marshal_VkSubmitInfo(countingStream, (VkSubmitInfo*)(local_pSubmits + i));
+        }
+        uint64_t cgen_var_79;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_79, 1);
+        countingStream->write((uint64_t*)&cgen_var_79, 1 * 8);
+    }
+    uint32_t packetSize_vkQueueSubmit = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueSubmit = OP_vkQueueSubmit;
+    stream->write(&opcode_vkQueueSubmit, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueSubmit, sizeof(uint32_t));
+    uint64_t cgen_var_80;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_80, 1);
+    stream->write((uint64_t*)&cgen_var_80, 1 * 8);
+    stream->write((uint32_t*)&local_submitCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
+    {
+        marshal_VkSubmitInfo(stream, (VkSubmitInfo*)(local_pSubmits + i));
+    }
+    uint64_t cgen_var_81;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_81, 1);
+    stream->write((uint64_t*)&cgen_var_81, 1 * 8);
+    VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
+    stream->read(&vkQueueSubmit_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkQueueSubmit_VkResult_return;
+}
+
+VkResult VkEncoder::vkQueueWaitIdle(
+    VkQueue queue)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkQueue local_queue;
+    local_queue = queue;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_82;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_82, 1);
+        countingStream->write((uint64_t*)&cgen_var_82, 1 * 8);
+    }
+    uint32_t packetSize_vkQueueWaitIdle = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueWaitIdle = OP_vkQueueWaitIdle;
+    stream->write(&opcode_vkQueueWaitIdle, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueWaitIdle, sizeof(uint32_t));
+    uint64_t cgen_var_83;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_83, 1);
+    stream->write((uint64_t*)&cgen_var_83, 1 * 8);
+    VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
+    stream->read(&vkQueueWaitIdle_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkQueueWaitIdle_VkResult_return;
+}
+
+VkResult VkEncoder::vkDeviceWaitIdle(
+    VkDevice device)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    local_device = device;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_84;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_84, 1);
+        countingStream->write((uint64_t*)&cgen_var_84, 1 * 8);
+    }
+    uint32_t packetSize_vkDeviceWaitIdle = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDeviceWaitIdle = OP_vkDeviceWaitIdle;
+    stream->write(&opcode_vkDeviceWaitIdle, sizeof(uint32_t));
+    stream->write(&packetSize_vkDeviceWaitIdle, sizeof(uint32_t));
+    uint64_t cgen_var_85;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_85, 1);
+    stream->write((uint64_t*)&cgen_var_85, 1 * 8);
+    VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
+    stream->read(&vkDeviceWaitIdle_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkDeviceWaitIdle_VkResult_return;
+}
+
+VkResult VkEncoder::vkAllocateMemory(
+    VkDevice device,
+    const VkMemoryAllocateInfo* pAllocateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDeviceMemory* pMemory)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkMemoryAllocateInfo* local_pAllocateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pAllocateInfo = nullptr;
+    if (pAllocateInfo)
+    {
+        local_pAllocateInfo = (VkMemoryAllocateInfo*)pool->alloc(sizeof(const VkMemoryAllocateInfo));
+        deepcopy_VkMemoryAllocateInfo(pool, pAllocateInfo, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_86;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_86, 1);
+        countingStream->write((uint64_t*)&cgen_var_86, 1 * 8);
+        marshal_VkMemoryAllocateInfo(countingStream, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_87 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_87);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_88;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_88, 1);
+        countingStream->write((uint64_t*)&cgen_var_88, 8);
+    }
+    uint32_t packetSize_vkAllocateMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkAllocateMemory = OP_vkAllocateMemory;
+    stream->write(&opcode_vkAllocateMemory, sizeof(uint32_t));
+    stream->write(&packetSize_vkAllocateMemory, sizeof(uint32_t));
+    uint64_t cgen_var_89;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_89, 1);
+    stream->write((uint64_t*)&cgen_var_89, 1 * 8);
+    marshal_VkMemoryAllocateInfo(stream, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_90 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_90);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_91;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_91, 1);
+    stream->write((uint64_t*)&cgen_var_91, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_92;
+    stream->read((uint64_t*)&cgen_var_92, 8);
+    stream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_92, (VkDeviceMemory*)pMemory, 1);
+    stream->unsetHandleMapping();
+    VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
+    stream->read(&vkAllocateMemory_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    goldfish_vkAllocateMemory(this, vkAllocateMemory_VkResult_return, device, pAllocateInfo, pAllocator, pMemory);
+    return vkAllocateMemory_VkResult_return;
+}
+
+void VkEncoder::vkFreeMemory(
+    VkDevice device,
+    VkDeviceMemory memory,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDeviceMemory local_memory;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_memory = memory;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_93;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_93, 1);
+        countingStream->write((uint64_t*)&cgen_var_93, 1 * 8);
+        uint64_t cgen_var_94;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_94, 1);
+        countingStream->write((uint64_t*)&cgen_var_94, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_95 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_95);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkFreeMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkFreeMemory = OP_vkFreeMemory;
+    stream->write(&opcode_vkFreeMemory, sizeof(uint32_t));
+    stream->write(&packetSize_vkFreeMemory, sizeof(uint32_t));
+    uint64_t cgen_var_96;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_96, 1);
+    stream->write((uint64_t*)&cgen_var_96, 1 * 8);
+    uint64_t cgen_var_97;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_97, 1);
+    stream->write((uint64_t*)&cgen_var_97, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_98 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_98);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
+}
+
+VkResult VkEncoder::vkMapMemory(
+    VkDevice device,
+    VkDeviceMemory memory,
+    VkDeviceSize offset,
+    VkDeviceSize size,
+    VkMemoryMapFlags flags,
+    void** ppData)
+{
+    VkResult vkMapMemory_VkResult_return = (VkResult)0;
+    vkMapMemory_VkResult_return = goldfish_vkMapMemory(this, vkMapMemory_VkResult_return, device, memory, offset, size, flags, ppData);
+    return vkMapMemory_VkResult_return;
+}
+
+void VkEncoder::vkUnmapMemory(
+    VkDevice device,
+    VkDeviceMemory memory)
+{
+    goldfish_vkUnmapMemory(this, device, memory);
+}
+
+VkResult VkEncoder::vkFlushMappedMemoryRanges(
+    VkDevice device,
+    uint32_t memoryRangeCount,
+    const VkMappedMemoryRange* pMemoryRanges)
+{
+    VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkFlushMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_memoryRangeCount;
+    VkMappedMemoryRange* local_pMemoryRanges;
+    local_device = device;
+    local_memoryRangeCount = memoryRangeCount;
+    local_pMemoryRanges = nullptr;
+    if (pMemoryRanges)
+    {
+        local_pMemoryRanges = (VkMappedMemoryRange*)pool->alloc(((memoryRangeCount)) * sizeof(const VkMappedMemoryRange));
+        for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+        {
+            deepcopy_VkMappedMemoryRange(pool, pMemoryRanges + i, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_99;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_99, 1);
+        countingStream->write((uint64_t*)&cgen_var_99, 1 * 8);
+        countingStream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+        {
+            marshal_VkMappedMemoryRange(countingStream, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+        }
+    }
+    for (uint32_t i = 0; i < memoryRangeCount; ++i)
+    {
+        auto range = pMemoryRanges[i];
+        auto memory = pMemoryRanges[i].memory;
+        auto size = pMemoryRanges[i].size;
+        auto offset = pMemoryRanges[i].offset;
+        auto goldfishMem = as_goldfish_VkDeviceMemory(memory);
+        uint64_t streamSize = 0;
+        if (!goldfishMem) { countingStream->write(&streamSize, sizeof(uint64_t)); continue; };
+        auto hostPtr = goldfishMem->ptr;
+        auto actualSize = size == VK_WHOLE_SIZE ? goldfishMem->size : size;
+        if (!hostPtr) { countingStream->write(&streamSize, sizeof(uint64_t)); continue; };
+        streamSize = actualSize;
+        countingStream->write(&streamSize, sizeof(uint64_t));
+        uint8_t* targetRange = hostPtr + offset;
+        countingStream->write(targetRange, actualSize);
+    }
+    uint32_t packetSize_vkFlushMappedMemoryRanges = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkFlushMappedMemoryRanges = OP_vkFlushMappedMemoryRanges;
+    stream->write(&opcode_vkFlushMappedMemoryRanges, sizeof(uint32_t));
+    stream->write(&packetSize_vkFlushMappedMemoryRanges, sizeof(uint32_t));
+    uint64_t cgen_var_100;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_100, 1);
+    stream->write((uint64_t*)&cgen_var_100, 1 * 8);
+    stream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+    {
+        marshal_VkMappedMemoryRange(stream, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+    }
+    for (uint32_t i = 0; i < memoryRangeCount; ++i)
+    {
+        auto range = pMemoryRanges[i];
+        auto memory = pMemoryRanges[i].memory;
+        auto size = pMemoryRanges[i].size;
+        auto offset = pMemoryRanges[i].offset;
+        auto goldfishMem = as_goldfish_VkDeviceMemory(memory);
+        uint64_t streamSize = 0;
+        if (!goldfishMem) { stream->write(&streamSize, sizeof(uint64_t)); continue; };
+        auto hostPtr = goldfishMem->ptr;
+        auto actualSize = size == VK_WHOLE_SIZE ? goldfishMem->size : size;
+        if (!hostPtr) { stream->write(&streamSize, sizeof(uint64_t)); continue; };
+        streamSize = actualSize;
+        stream->write(&streamSize, sizeof(uint64_t));
+        uint8_t* targetRange = hostPtr + offset;
+        stream->write(targetRange, actualSize);
+    }
+    VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
+    stream->read(&vkFlushMappedMemoryRanges_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkFlushMappedMemoryRanges_VkResult_return;
+}
+
+VkResult VkEncoder::vkInvalidateMappedMemoryRanges(
+    VkDevice device,
+    uint32_t memoryRangeCount,
+    const VkMappedMemoryRange* pMemoryRanges)
+{
+    VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkInvalidateMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_memoryRangeCount;
+    VkMappedMemoryRange* local_pMemoryRanges;
+    local_device = device;
+    local_memoryRangeCount = memoryRangeCount;
+    local_pMemoryRanges = nullptr;
+    if (pMemoryRanges)
+    {
+        local_pMemoryRanges = (VkMappedMemoryRange*)pool->alloc(((memoryRangeCount)) * sizeof(const VkMappedMemoryRange));
+        for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+        {
+            deepcopy_VkMappedMemoryRange(pool, pMemoryRanges + i, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_101;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_101, 1);
+        countingStream->write((uint64_t*)&cgen_var_101, 1 * 8);
+        countingStream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+        {
+            marshal_VkMappedMemoryRange(countingStream, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+        }
+    }
+    uint32_t packetSize_vkInvalidateMappedMemoryRanges = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkInvalidateMappedMemoryRanges = OP_vkInvalidateMappedMemoryRanges;
+    stream->write(&opcode_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
+    stream->write(&packetSize_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
+    uint64_t cgen_var_102;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_102, 1);
+    stream->write((uint64_t*)&cgen_var_102, 1 * 8);
+    stream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+    {
+        marshal_VkMappedMemoryRange(stream, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+    }
+    VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
+    stream->read(&vkInvalidateMappedMemoryRanges_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    for (uint32_t i = 0; i < memoryRangeCount; ++i)
+    {
+        auto range = pMemoryRanges[i];
+        auto memory = pMemoryRanges[i].memory;
+        auto size = pMemoryRanges[i].size;
+        auto offset = pMemoryRanges[i].offset;
+        auto goldfishMem = as_goldfish_VkDeviceMemory(memory);
+        uint64_t streamSize = 0;
+        if (!goldfishMem) { stream->read(&streamSize, sizeof(uint64_t)); continue; };
+        auto hostPtr = goldfishMem->ptr;
+        auto actualSize = size == VK_WHOLE_SIZE ? goldfishMem->size : size;
+        if (!hostPtr) { stream->read(&streamSize, sizeof(uint64_t)); continue; };
+        streamSize = actualSize;
+        stream->read(&streamSize, sizeof(uint64_t));
+        uint8_t* targetRange = hostPtr + offset;
+        stream->read(targetRange, actualSize);
+    }
+    return vkInvalidateMappedMemoryRanges_VkResult_return;
+}
+
+void VkEncoder::vkGetDeviceMemoryCommitment(
+    VkDevice device,
+    VkDeviceMemory memory,
+    VkDeviceSize* pCommittedMemoryInBytes)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDeviceMemory local_memory;
+    local_device = device;
+    local_memory = memory;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_103;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_103, 1);
+        countingStream->write((uint64_t*)&cgen_var_103, 1 * 8);
+        uint64_t cgen_var_104;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_104, 1);
+        countingStream->write((uint64_t*)&cgen_var_104, 1 * 8);
+        countingStream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
+    }
+    uint32_t packetSize_vkGetDeviceMemoryCommitment = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDeviceMemoryCommitment = OP_vkGetDeviceMemoryCommitment;
+    stream->write(&opcode_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
+    uint64_t cgen_var_105;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_105, 1);
+    stream->write((uint64_t*)&cgen_var_105, 1 * 8);
+    uint64_t cgen_var_106;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_106, 1);
+    stream->write((uint64_t*)&cgen_var_106, 1 * 8);
+    stream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
+    stream->read((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
+}
+
+VkResult VkEncoder::vkBindBufferMemory(
+    VkDevice device,
+    VkBuffer buffer,
+    VkDeviceMemory memory,
+    VkDeviceSize memoryOffset)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkBuffer local_buffer;
+    VkDeviceMemory local_memory;
+    VkDeviceSize local_memoryOffset;
+    local_device = device;
+    local_buffer = buffer;
+    local_memory = memory;
+    local_memoryOffset = memoryOffset;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_107;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_107, 1);
+        countingStream->write((uint64_t*)&cgen_var_107, 1 * 8);
+        uint64_t cgen_var_108;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_108, 1);
+        countingStream->write((uint64_t*)&cgen_var_108, 1 * 8);
+        uint64_t cgen_var_109;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_109, 1);
+        countingStream->write((uint64_t*)&cgen_var_109, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
+    }
+    uint32_t packetSize_vkBindBufferMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkBindBufferMemory = OP_vkBindBufferMemory;
+    stream->write(&opcode_vkBindBufferMemory, sizeof(uint32_t));
+    stream->write(&packetSize_vkBindBufferMemory, sizeof(uint32_t));
+    uint64_t cgen_var_110;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_110, 1);
+    stream->write((uint64_t*)&cgen_var_110, 1 * 8);
+    uint64_t cgen_var_111;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_111, 1);
+    stream->write((uint64_t*)&cgen_var_111, 1 * 8);
+    uint64_t cgen_var_112;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_112, 1);
+    stream->write((uint64_t*)&cgen_var_112, 1 * 8);
+    stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
+    VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
+    stream->read(&vkBindBufferMemory_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkBindBufferMemory_VkResult_return;
+}
+
+VkResult VkEncoder::vkBindImageMemory(
+    VkDevice device,
+    VkImage image,
+    VkDeviceMemory memory,
+    VkDeviceSize memoryOffset)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImage local_image;
+    VkDeviceMemory local_memory;
+    VkDeviceSize local_memoryOffset;
+    local_device = device;
+    local_image = image;
+    local_memory = memory;
+    local_memoryOffset = memoryOffset;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_113;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_113, 1);
+        countingStream->write((uint64_t*)&cgen_var_113, 1 * 8);
+        uint64_t cgen_var_114;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_114, 1);
+        countingStream->write((uint64_t*)&cgen_var_114, 1 * 8);
+        uint64_t cgen_var_115;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_115, 1);
+        countingStream->write((uint64_t*)&cgen_var_115, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
+    }
+    uint32_t packetSize_vkBindImageMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkBindImageMemory = OP_vkBindImageMemory;
+    stream->write(&opcode_vkBindImageMemory, sizeof(uint32_t));
+    stream->write(&packetSize_vkBindImageMemory, sizeof(uint32_t));
+    uint64_t cgen_var_116;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_116, 1);
+    stream->write((uint64_t*)&cgen_var_116, 1 * 8);
+    uint64_t cgen_var_117;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_117, 1);
+    stream->write((uint64_t*)&cgen_var_117, 1 * 8);
+    uint64_t cgen_var_118;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_118, 1);
+    stream->write((uint64_t*)&cgen_var_118, 1 * 8);
+    stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
+    VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
+    stream->read(&vkBindImageMemory_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkBindImageMemory_VkResult_return;
+}
+
+void VkEncoder::vkGetBufferMemoryRequirements(
+    VkDevice device,
+    VkBuffer buffer,
+    VkMemoryRequirements* pMemoryRequirements)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkBuffer local_buffer;
+    local_device = device;
+    local_buffer = buffer;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_119;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_119, 1);
+        countingStream->write((uint64_t*)&cgen_var_119, 1 * 8);
+        uint64_t cgen_var_120;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_120, 1);
+        countingStream->write((uint64_t*)&cgen_var_120, 1 * 8);
+        marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
+    }
+    uint32_t packetSize_vkGetBufferMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetBufferMemoryRequirements = OP_vkGetBufferMemoryRequirements;
+    stream->write(&opcode_vkGetBufferMemoryRequirements, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetBufferMemoryRequirements, sizeof(uint32_t));
+    uint64_t cgen_var_121;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_121, 1);
+    stream->write((uint64_t*)&cgen_var_121, 1 * 8);
+    uint64_t cgen_var_122;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_122, 1);
+    stream->write((uint64_t*)&cgen_var_122, 1 * 8);
+    marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+    unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetImageMemoryRequirements(
+    VkDevice device,
+    VkImage image,
+    VkMemoryRequirements* pMemoryRequirements)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImage local_image;
+    local_device = device;
+    local_image = image;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_123;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_123, 1);
+        countingStream->write((uint64_t*)&cgen_var_123, 1 * 8);
+        uint64_t cgen_var_124;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_124, 1);
+        countingStream->write((uint64_t*)&cgen_var_124, 1 * 8);
+        marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
+    }
+    uint32_t packetSize_vkGetImageMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetImageMemoryRequirements = OP_vkGetImageMemoryRequirements;
+    stream->write(&opcode_vkGetImageMemoryRequirements, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetImageMemoryRequirements, sizeof(uint32_t));
+    uint64_t cgen_var_125;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_125, 1);
+    stream->write((uint64_t*)&cgen_var_125, 1 * 8);
+    uint64_t cgen_var_126;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_126, 1);
+    stream->write((uint64_t*)&cgen_var_126, 1 * 8);
+    marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+    unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetImageSparseMemoryRequirements(
+    VkDevice device,
+    VkImage image,
+    uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImage local_image;
+    local_device = device;
+    local_image = image;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_127;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_127, 1);
+        countingStream->write((uint64_t*)&cgen_var_127, 1 * 8);
+        uint64_t cgen_var_128;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_128, 1);
+        countingStream->write((uint64_t*)&cgen_var_128, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_129 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+        countingStream->putBe64(cgen_var_129);
+        if (pSparseMemoryRequirementCount)
+        {
+            countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_130 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+        countingStream->putBe64(cgen_var_130);
+        if (pSparseMemoryRequirements)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+            {
+                marshal_VkSparseImageMemoryRequirements(countingStream, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetImageSparseMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetImageSparseMemoryRequirements = OP_vkGetImageSparseMemoryRequirements;
+    stream->write(&opcode_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
+    uint64_t cgen_var_131;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_131, 1);
+    stream->write((uint64_t*)&cgen_var_131, 1 * 8);
+    uint64_t cgen_var_132;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_132, 1);
+    stream->write((uint64_t*)&cgen_var_132, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_133 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+    stream->putBe64(cgen_var_133);
+    if (pSparseMemoryRequirementCount)
+    {
+        stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_134 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+    stream->putBe64(cgen_var_134);
+    if (pSparseMemoryRequirements)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+        {
+            marshal_VkSparseImageMemoryRequirements(stream, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pSparseMemoryRequirementCount;
+    check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pSparseMemoryRequirementCount)
+    {
+        if (!(check_pSparseMemoryRequirementCount))
+        {
+            fprintf(stderr, "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkSparseImageMemoryRequirements* check_pSparseMemoryRequirements;
+    check_pSparseMemoryRequirements = (VkSparseImageMemoryRequirements*)(uintptr_t)stream->getBe64();
+    if (pSparseMemoryRequirements)
+    {
+        if (!(check_pSparseMemoryRequirements))
+        {
+            fprintf(stderr, "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+        {
+            unmarshal_VkSparseImageMemoryRequirements(stream, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
+        }
+    }
+}
+
+void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkImageType type,
+    VkSampleCountFlagBits samples,
+    VkImageUsageFlags usage,
+    VkImageTiling tiling,
+    uint32_t* pPropertyCount,
+    VkSparseImageFormatProperties* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkFormat local_format;
+    VkImageType local_type;
+    VkSampleCountFlagBits local_samples;
+    VkImageUsageFlags local_usage;
+    VkImageTiling local_tiling;
+    local_physicalDevice = physicalDevice;
+    local_format = format;
+    local_type = type;
+    local_samples = samples;
+    local_usage = usage;
+    local_tiling = tiling;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_137;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_137, 1);
+        countingStream->write((uint64_t*)&cgen_var_137, 1 * 8);
+        countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+        countingStream->write((VkImageType*)&local_type, sizeof(VkImageType));
+        countingStream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
+        countingStream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+        countingStream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_138 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_138);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_139 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_139);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkSparseImageFormatProperties(countingStream, (VkSparseImageFormatProperties*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties = OP_vkGetPhysicalDeviceSparseImageFormatProperties;
+    stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
+    uint64_t cgen_var_140;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_140, 1);
+    stream->write((uint64_t*)&cgen_var_140, 1 * 8);
+    stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+    stream->write((VkImageType*)&local_type, sizeof(VkImageType));
+    stream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
+    stream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+    stream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_141 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_141);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_142 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_142);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkSparseImageFormatProperties(stream, (VkSparseImageFormatProperties*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkSparseImageFormatProperties* check_pProperties;
+    check_pProperties = (VkSparseImageFormatProperties*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkSparseImageFormatProperties(stream, (VkSparseImageFormatProperties*)(pProperties + i));
+        }
+    }
+}
+
+VkResult VkEncoder::vkQueueBindSparse(
+    VkQueue queue,
+    uint32_t bindInfoCount,
+    const VkBindSparseInfo* pBindInfo,
+    VkFence fence)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkQueue local_queue;
+    uint32_t local_bindInfoCount;
+    VkBindSparseInfo* local_pBindInfo;
+    VkFence local_fence;
+    local_queue = queue;
+    local_bindInfoCount = bindInfoCount;
+    local_pBindInfo = nullptr;
+    if (pBindInfo)
+    {
+        local_pBindInfo = (VkBindSparseInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindSparseInfo));
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            deepcopy_VkBindSparseInfo(pool, pBindInfo + i, (VkBindSparseInfo*)(local_pBindInfo + i));
+        }
+    }
+    local_fence = fence;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_145;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_145, 1);
+        countingStream->write((uint64_t*)&cgen_var_145, 1 * 8);
+        countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            marshal_VkBindSparseInfo(countingStream, (VkBindSparseInfo*)(local_pBindInfo + i));
+        }
+        uint64_t cgen_var_146;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_146, 1);
+        countingStream->write((uint64_t*)&cgen_var_146, 1 * 8);
+    }
+    uint32_t packetSize_vkQueueBindSparse = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueBindSparse = OP_vkQueueBindSparse;
+    stream->write(&opcode_vkQueueBindSparse, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueBindSparse, sizeof(uint32_t));
+    uint64_t cgen_var_147;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_147, 1);
+    stream->write((uint64_t*)&cgen_var_147, 1 * 8);
+    stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+    {
+        marshal_VkBindSparseInfo(stream, (VkBindSparseInfo*)(local_pBindInfo + i));
+    }
+    uint64_t cgen_var_148;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_148, 1);
+    stream->write((uint64_t*)&cgen_var_148, 1 * 8);
+    VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
+    stream->read(&vkQueueBindSparse_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkQueueBindSparse_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateFence(
+    VkDevice device,
+    const VkFenceCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkFence* pFence)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkFenceCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkFenceCreateInfo*)pool->alloc(sizeof(const VkFenceCreateInfo));
+        deepcopy_VkFenceCreateInfo(pool, pCreateInfo, (VkFenceCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_149;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_149, 1);
+        countingStream->write((uint64_t*)&cgen_var_149, 1 * 8);
+        marshal_VkFenceCreateInfo(countingStream, (VkFenceCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_150 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_150);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_151;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_151, 1);
+        countingStream->write((uint64_t*)&cgen_var_151, 8);
+    }
+    uint32_t packetSize_vkCreateFence = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateFence = OP_vkCreateFence;
+    stream->write(&opcode_vkCreateFence, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateFence, sizeof(uint32_t));
+    uint64_t cgen_var_152;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_152, 1);
+    stream->write((uint64_t*)&cgen_var_152, 1 * 8);
+    marshal_VkFenceCreateInfo(stream, (VkFenceCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_153 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_153);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_154;
+    stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_154, 1);
+    stream->write((uint64_t*)&cgen_var_154, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_155;
+    stream->read((uint64_t*)&cgen_var_155, 8);
+    stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_155, (VkFence*)pFence, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateFence_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateFence_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateFence_VkResult_return;
+}
+
+void VkEncoder::vkDestroyFence(
+    VkDevice device,
+    VkFence fence,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkFence local_fence;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_fence = fence;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_156;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_156, 1);
+        countingStream->write((uint64_t*)&cgen_var_156, 1 * 8);
+        uint64_t cgen_var_157;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_157, 1);
+        countingStream->write((uint64_t*)&cgen_var_157, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_158 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_158);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyFence = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyFence = OP_vkDestroyFence;
+    stream->write(&opcode_vkDestroyFence, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyFence, sizeof(uint32_t));
+    uint64_t cgen_var_159;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_159, 1);
+    stream->write((uint64_t*)&cgen_var_159, 1 * 8);
+    uint64_t cgen_var_160;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_160, 1);
+    stream->write((uint64_t*)&cgen_var_160, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_161 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_161);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkFence((VkFence*)&fence);
+}
+
+VkResult VkEncoder::vkResetFences(
+    VkDevice device,
+    uint32_t fenceCount,
+    const VkFence* pFences)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_fenceCount;
+    VkFence* local_pFences;
+    local_device = device;
+    local_fenceCount = fenceCount;
+    local_pFences = nullptr;
+    if (pFences)
+    {
+        local_pFences = (VkFence*)pool->dupArray(pFences, ((fenceCount)) * sizeof(const VkFence));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_162;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_162, 1);
+        countingStream->write((uint64_t*)&cgen_var_162, 1 * 8);
+        countingStream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
+        if (((fenceCount)))
+        {
+            uint64_t* cgen_var_163;
+            countingStream->alloc((void**)&cgen_var_163, ((fenceCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_163, ((fenceCount)));
+            countingStream->write((uint64_t*)cgen_var_163, ((fenceCount)) * 8);
+        }
+    }
+    uint32_t packetSize_vkResetFences = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkResetFences = OP_vkResetFences;
+    stream->write(&opcode_vkResetFences, sizeof(uint32_t));
+    stream->write(&packetSize_vkResetFences, sizeof(uint32_t));
+    uint64_t cgen_var_164;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_164, 1);
+    stream->write((uint64_t*)&cgen_var_164, 1 * 8);
+    stream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
+    if (((fenceCount)))
+    {
+        uint64_t* cgen_var_165;
+        stream->alloc((void**)&cgen_var_165, ((fenceCount)) * 8);
+        stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_165, ((fenceCount)));
+        stream->write((uint64_t*)cgen_var_165, ((fenceCount)) * 8);
+    }
+    VkResult vkResetFences_VkResult_return = (VkResult)0;
+    stream->read(&vkResetFences_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkResetFences_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetFenceStatus(
+    VkDevice device,
+    VkFence fence)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkFence local_fence;
+    local_device = device;
+    local_fence = fence;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_166;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_166, 1);
+        countingStream->write((uint64_t*)&cgen_var_166, 1 * 8);
+        uint64_t cgen_var_167;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_167, 1);
+        countingStream->write((uint64_t*)&cgen_var_167, 1 * 8);
+    }
+    uint32_t packetSize_vkGetFenceStatus = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetFenceStatus = OP_vkGetFenceStatus;
+    stream->write(&opcode_vkGetFenceStatus, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetFenceStatus, sizeof(uint32_t));
+    uint64_t cgen_var_168;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_168, 1);
+    stream->write((uint64_t*)&cgen_var_168, 1 * 8);
+    uint64_t cgen_var_169;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_169, 1);
+    stream->write((uint64_t*)&cgen_var_169, 1 * 8);
+    VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
+    stream->read(&vkGetFenceStatus_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetFenceStatus_VkResult_return;
+}
+
+VkResult VkEncoder::vkWaitForFences(
+    VkDevice device,
+    uint32_t fenceCount,
+    const VkFence* pFences,
+    VkBool32 waitAll,
+    uint64_t timeout)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_fenceCount;
+    VkFence* local_pFences;
+    VkBool32 local_waitAll;
+    uint64_t local_timeout;
+    local_device = device;
+    local_fenceCount = fenceCount;
+    local_pFences = nullptr;
+    if (pFences)
+    {
+        local_pFences = (VkFence*)pool->dupArray(pFences, ((fenceCount)) * sizeof(const VkFence));
+    }
+    local_waitAll = waitAll;
+    local_timeout = timeout;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_170;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_170, 1);
+        countingStream->write((uint64_t*)&cgen_var_170, 1 * 8);
+        countingStream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
+        if (((fenceCount)))
+        {
+            uint64_t* cgen_var_171;
+            countingStream->alloc((void**)&cgen_var_171, ((fenceCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_171, ((fenceCount)));
+            countingStream->write((uint64_t*)cgen_var_171, ((fenceCount)) * 8);
+        }
+        countingStream->write((VkBool32*)&local_waitAll, sizeof(VkBool32));
+        countingStream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
+    }
+    uint32_t packetSize_vkWaitForFences = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkWaitForFences = OP_vkWaitForFences;
+    stream->write(&opcode_vkWaitForFences, sizeof(uint32_t));
+    stream->write(&packetSize_vkWaitForFences, sizeof(uint32_t));
+    uint64_t cgen_var_172;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_172, 1);
+    stream->write((uint64_t*)&cgen_var_172, 1 * 8);
+    stream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
+    if (((fenceCount)))
+    {
+        uint64_t* cgen_var_173;
+        stream->alloc((void**)&cgen_var_173, ((fenceCount)) * 8);
+        stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_173, ((fenceCount)));
+        stream->write((uint64_t*)cgen_var_173, ((fenceCount)) * 8);
+    }
+    stream->write((VkBool32*)&local_waitAll, sizeof(VkBool32));
+    stream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
+    VkResult vkWaitForFences_VkResult_return = (VkResult)0;
+    stream->read(&vkWaitForFences_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkWaitForFences_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateSemaphore(
+    VkDevice device,
+    const VkSemaphoreCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSemaphore* pSemaphore)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSemaphoreCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkSemaphoreCreateInfo*)pool->alloc(sizeof(const VkSemaphoreCreateInfo));
+        deepcopy_VkSemaphoreCreateInfo(pool, pCreateInfo, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_174;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_174, 1);
+        countingStream->write((uint64_t*)&cgen_var_174, 1 * 8);
+        marshal_VkSemaphoreCreateInfo(countingStream, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_175 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_175);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_176;
+        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_176, 1);
+        countingStream->write((uint64_t*)&cgen_var_176, 8);
+    }
+    uint32_t packetSize_vkCreateSemaphore = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateSemaphore = OP_vkCreateSemaphore;
+    stream->write(&opcode_vkCreateSemaphore, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateSemaphore, sizeof(uint32_t));
+    uint64_t cgen_var_177;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_177, 1);
+    stream->write((uint64_t*)&cgen_var_177, 1 * 8);
+    marshal_VkSemaphoreCreateInfo(stream, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_178 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_178);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_179;
+    stream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_179, 1);
+    stream->write((uint64_t*)&cgen_var_179, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_180;
+    stream->read((uint64_t*)&cgen_var_180, 8);
+    stream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_180, (VkSemaphore*)pSemaphore, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateSemaphore_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateSemaphore_VkResult_return;
+}
+
+void VkEncoder::vkDestroySemaphore(
+    VkDevice device,
+    VkSemaphore semaphore,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSemaphore local_semaphore;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_semaphore = semaphore;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_181;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_181, 1);
+        countingStream->write((uint64_t*)&cgen_var_181, 1 * 8);
+        uint64_t cgen_var_182;
+        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_182, 1);
+        countingStream->write((uint64_t*)&cgen_var_182, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_183 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_183);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroySemaphore = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroySemaphore = OP_vkDestroySemaphore;
+    stream->write(&opcode_vkDestroySemaphore, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroySemaphore, sizeof(uint32_t));
+    uint64_t cgen_var_184;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_184, 1);
+    stream->write((uint64_t*)&cgen_var_184, 1 * 8);
+    uint64_t cgen_var_185;
+    stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_185, 1);
+    stream->write((uint64_t*)&cgen_var_185, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_186 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_186);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkSemaphore((VkSemaphore*)&semaphore);
+}
+
+VkResult VkEncoder::vkCreateEvent(
+    VkDevice device,
+    const VkEventCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkEvent* pEvent)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkEventCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkEventCreateInfo*)pool->alloc(sizeof(const VkEventCreateInfo));
+        deepcopy_VkEventCreateInfo(pool, pCreateInfo, (VkEventCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_187;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_187, 1);
+        countingStream->write((uint64_t*)&cgen_var_187, 1 * 8);
+        marshal_VkEventCreateInfo(countingStream, (VkEventCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_188 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_188);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_189;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_189, 1);
+        countingStream->write((uint64_t*)&cgen_var_189, 8);
+    }
+    uint32_t packetSize_vkCreateEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateEvent = OP_vkCreateEvent;
+    stream->write(&opcode_vkCreateEvent, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateEvent, sizeof(uint32_t));
+    uint64_t cgen_var_190;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_190, 1);
+    stream->write((uint64_t*)&cgen_var_190, 1 * 8);
+    marshal_VkEventCreateInfo(stream, (VkEventCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_191 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_191);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_192;
+    stream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_192, 1);
+    stream->write((uint64_t*)&cgen_var_192, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_193;
+    stream->read((uint64_t*)&cgen_var_193, 8);
+    stream->handleMapping()->mapHandles_u64_VkEvent(&cgen_var_193, (VkEvent*)pEvent, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateEvent_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateEvent_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateEvent_VkResult_return;
+}
+
+void VkEncoder::vkDestroyEvent(
+    VkDevice device,
+    VkEvent event,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkEvent local_event;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_event = event;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_194;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_194, 1);
+        countingStream->write((uint64_t*)&cgen_var_194, 1 * 8);
+        uint64_t cgen_var_195;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_195, 1);
+        countingStream->write((uint64_t*)&cgen_var_195, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_196 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_196);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyEvent = OP_vkDestroyEvent;
+    stream->write(&opcode_vkDestroyEvent, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyEvent, sizeof(uint32_t));
+    uint64_t cgen_var_197;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_197, 1);
+    stream->write((uint64_t*)&cgen_var_197, 1 * 8);
+    uint64_t cgen_var_198;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_198, 1);
+    stream->write((uint64_t*)&cgen_var_198, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_199 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_199);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkEvent((VkEvent*)&event);
+}
+
+VkResult VkEncoder::vkGetEventStatus(
+    VkDevice device,
+    VkEvent event)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkEvent local_event;
+    local_device = device;
+    local_event = event;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_200;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_200, 1);
+        countingStream->write((uint64_t*)&cgen_var_200, 1 * 8);
+        uint64_t cgen_var_201;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_201, 1);
+        countingStream->write((uint64_t*)&cgen_var_201, 1 * 8);
+    }
+    uint32_t packetSize_vkGetEventStatus = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetEventStatus = OP_vkGetEventStatus;
+    stream->write(&opcode_vkGetEventStatus, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetEventStatus, sizeof(uint32_t));
+    uint64_t cgen_var_202;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_202, 1);
+    stream->write((uint64_t*)&cgen_var_202, 1 * 8);
+    uint64_t cgen_var_203;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_203, 1);
+    stream->write((uint64_t*)&cgen_var_203, 1 * 8);
+    VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
+    stream->read(&vkGetEventStatus_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetEventStatus_VkResult_return;
+}
+
+VkResult VkEncoder::vkSetEvent(
+    VkDevice device,
+    VkEvent event)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkEvent local_event;
+    local_device = device;
+    local_event = event;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_204;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_204, 1);
+        countingStream->write((uint64_t*)&cgen_var_204, 1 * 8);
+        uint64_t cgen_var_205;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_205, 1);
+        countingStream->write((uint64_t*)&cgen_var_205, 1 * 8);
+    }
+    uint32_t packetSize_vkSetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkSetEvent = OP_vkSetEvent;
+    stream->write(&opcode_vkSetEvent, sizeof(uint32_t));
+    stream->write(&packetSize_vkSetEvent, sizeof(uint32_t));
+    uint64_t cgen_var_206;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_206, 1);
+    stream->write((uint64_t*)&cgen_var_206, 1 * 8);
+    uint64_t cgen_var_207;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_207, 1);
+    stream->write((uint64_t*)&cgen_var_207, 1 * 8);
+    VkResult vkSetEvent_VkResult_return = (VkResult)0;
+    stream->read(&vkSetEvent_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkSetEvent_VkResult_return;
+}
+
+VkResult VkEncoder::vkResetEvent(
+    VkDevice device,
+    VkEvent event)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkEvent local_event;
+    local_device = device;
+    local_event = event;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_208;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_208, 1);
+        countingStream->write((uint64_t*)&cgen_var_208, 1 * 8);
+        uint64_t cgen_var_209;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_209, 1);
+        countingStream->write((uint64_t*)&cgen_var_209, 1 * 8);
+    }
+    uint32_t packetSize_vkResetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkResetEvent = OP_vkResetEvent;
+    stream->write(&opcode_vkResetEvent, sizeof(uint32_t));
+    stream->write(&packetSize_vkResetEvent, sizeof(uint32_t));
+    uint64_t cgen_var_210;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_210, 1);
+    stream->write((uint64_t*)&cgen_var_210, 1 * 8);
+    uint64_t cgen_var_211;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_211, 1);
+    stream->write((uint64_t*)&cgen_var_211, 1 * 8);
+    VkResult vkResetEvent_VkResult_return = (VkResult)0;
+    stream->read(&vkResetEvent_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkResetEvent_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateQueryPool(
+    VkDevice device,
+    const VkQueryPoolCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkQueryPool* pQueryPool)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkQueryPoolCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkQueryPoolCreateInfo*)pool->alloc(sizeof(const VkQueryPoolCreateInfo));
+        deepcopy_VkQueryPoolCreateInfo(pool, pCreateInfo, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_212;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_212, 1);
+        countingStream->write((uint64_t*)&cgen_var_212, 1 * 8);
+        marshal_VkQueryPoolCreateInfo(countingStream, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_213 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_213);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_214;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_214, 1);
+        countingStream->write((uint64_t*)&cgen_var_214, 8);
+    }
+    uint32_t packetSize_vkCreateQueryPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateQueryPool = OP_vkCreateQueryPool;
+    stream->write(&opcode_vkCreateQueryPool, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateQueryPool, sizeof(uint32_t));
+    uint64_t cgen_var_215;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_215, 1);
+    stream->write((uint64_t*)&cgen_var_215, 1 * 8);
+    marshal_VkQueryPoolCreateInfo(stream, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_216 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_216);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_217;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_217, 1);
+    stream->write((uint64_t*)&cgen_var_217, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_218;
+    stream->read((uint64_t*)&cgen_var_218, 8);
+    stream->handleMapping()->mapHandles_u64_VkQueryPool(&cgen_var_218, (VkQueryPool*)pQueryPool, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateQueryPool_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateQueryPool_VkResult_return;
+}
+
+void VkEncoder::vkDestroyQueryPool(
+    VkDevice device,
+    VkQueryPool queryPool,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkQueryPool local_queryPool;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_queryPool = queryPool;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_219;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_219, 1);
+        countingStream->write((uint64_t*)&cgen_var_219, 1 * 8);
+        uint64_t cgen_var_220;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_220, 1);
+        countingStream->write((uint64_t*)&cgen_var_220, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_221 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_221);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyQueryPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyQueryPool = OP_vkDestroyQueryPool;
+    stream->write(&opcode_vkDestroyQueryPool, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyQueryPool, sizeof(uint32_t));
+    uint64_t cgen_var_222;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_222, 1);
+    stream->write((uint64_t*)&cgen_var_222, 1 * 8);
+    uint64_t cgen_var_223;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_223, 1);
+    stream->write((uint64_t*)&cgen_var_223, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_224 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_224);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkQueryPool((VkQueryPool*)&queryPool);
+}
+
+VkResult VkEncoder::vkGetQueryPoolResults(
+    VkDevice device,
+    VkQueryPool queryPool,
+    uint32_t firstQuery,
+    uint32_t queryCount,
+    size_t dataSize,
+    void* pData,
+    VkDeviceSize stride,
+    VkQueryResultFlags flags)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkQueryPool local_queryPool;
+    uint32_t local_firstQuery;
+    uint32_t local_queryCount;
+    size_t local_dataSize;
+    VkDeviceSize local_stride;
+    VkQueryResultFlags local_flags;
+    local_device = device;
+    local_queryPool = queryPool;
+    local_firstQuery = firstQuery;
+    local_queryCount = queryCount;
+    local_dataSize = dataSize;
+    local_stride = stride;
+    local_flags = flags;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_225;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_225, 1);
+        countingStream->write((uint64_t*)&cgen_var_225, 1 * 8);
+        uint64_t cgen_var_226;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_226, 1);
+        countingStream->write((uint64_t*)&cgen_var_226, 1 * 8);
+        countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+        uint64_t cgen_var_227 = (uint64_t)local_dataSize;
+        countingStream->putBe64(cgen_var_227);
+        countingStream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
+        countingStream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
+        countingStream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
+    }
+    uint32_t packetSize_vkGetQueryPoolResults = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetQueryPoolResults = OP_vkGetQueryPoolResults;
+    stream->write(&opcode_vkGetQueryPoolResults, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetQueryPoolResults, sizeof(uint32_t));
+    uint64_t cgen_var_228;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_228, 1);
+    stream->write((uint64_t*)&cgen_var_228, 1 * 8);
+    uint64_t cgen_var_229;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_229, 1);
+    stream->write((uint64_t*)&cgen_var_229, 1 * 8);
+    stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+    uint64_t cgen_var_230 = (uint64_t)local_dataSize;
+    stream->putBe64(cgen_var_230);
+    stream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
+    stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
+    stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
+    stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t));
+    VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
+    stream->read(&vkGetQueryPoolResults_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetQueryPoolResults_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateBuffer(
+    VkDevice device,
+    const VkBufferCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkBuffer* pBuffer)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkBufferCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkBufferCreateInfo*)pool->alloc(sizeof(const VkBufferCreateInfo));
+        deepcopy_VkBufferCreateInfo(pool, pCreateInfo, (VkBufferCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_231;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_231, 1);
+        countingStream->write((uint64_t*)&cgen_var_231, 1 * 8);
+        marshal_VkBufferCreateInfo(countingStream, (VkBufferCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_232 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_232);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_233;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_233, 1);
+        countingStream->write((uint64_t*)&cgen_var_233, 8);
+    }
+    uint32_t packetSize_vkCreateBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateBuffer = OP_vkCreateBuffer;
+    stream->write(&opcode_vkCreateBuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateBuffer, sizeof(uint32_t));
+    uint64_t cgen_var_234;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_234, 1);
+    stream->write((uint64_t*)&cgen_var_234, 1 * 8);
+    marshal_VkBufferCreateInfo(stream, (VkBufferCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_235 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_235);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_236;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_236, 1);
+    stream->write((uint64_t*)&cgen_var_236, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_237;
+    stream->read((uint64_t*)&cgen_var_237, 8);
+    stream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_237, (VkBuffer*)pBuffer, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateBuffer_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateBuffer_VkResult_return;
+}
+
+void VkEncoder::vkDestroyBuffer(
+    VkDevice device,
+    VkBuffer buffer,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkBuffer local_buffer;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_buffer = buffer;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_238;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_238, 1);
+        countingStream->write((uint64_t*)&cgen_var_238, 1 * 8);
+        uint64_t cgen_var_239;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_239, 1);
+        countingStream->write((uint64_t*)&cgen_var_239, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_240 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_240);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyBuffer = OP_vkDestroyBuffer;
+    stream->write(&opcode_vkDestroyBuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyBuffer, sizeof(uint32_t));
+    uint64_t cgen_var_241;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_241, 1);
+    stream->write((uint64_t*)&cgen_var_241, 1 * 8);
+    uint64_t cgen_var_242;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_242, 1);
+    stream->write((uint64_t*)&cgen_var_242, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_243 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_243);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkBuffer((VkBuffer*)&buffer);
+}
+
+VkResult VkEncoder::vkCreateBufferView(
+    VkDevice device,
+    const VkBufferViewCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkBufferView* pView)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkBufferViewCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkBufferViewCreateInfo*)pool->alloc(sizeof(const VkBufferViewCreateInfo));
+        deepcopy_VkBufferViewCreateInfo(pool, pCreateInfo, (VkBufferViewCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_244;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_244, 1);
+        countingStream->write((uint64_t*)&cgen_var_244, 1 * 8);
+        marshal_VkBufferViewCreateInfo(countingStream, (VkBufferViewCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_245 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_245);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_246;
+        countingStream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_246, 1);
+        countingStream->write((uint64_t*)&cgen_var_246, 8);
+    }
+    uint32_t packetSize_vkCreateBufferView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateBufferView = OP_vkCreateBufferView;
+    stream->write(&opcode_vkCreateBufferView, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateBufferView, sizeof(uint32_t));
+    uint64_t cgen_var_247;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_247, 1);
+    stream->write((uint64_t*)&cgen_var_247, 1 * 8);
+    marshal_VkBufferViewCreateInfo(stream, (VkBufferViewCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_248 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_248);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_249;
+    stream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_249, 1);
+    stream->write((uint64_t*)&cgen_var_249, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_250;
+    stream->read((uint64_t*)&cgen_var_250, 8);
+    stream->handleMapping()->mapHandles_u64_VkBufferView(&cgen_var_250, (VkBufferView*)pView, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateBufferView_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateBufferView_VkResult_return;
+}
+
+void VkEncoder::vkDestroyBufferView(
+    VkDevice device,
+    VkBufferView bufferView,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkBufferView local_bufferView;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_bufferView = bufferView;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_251;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_251, 1);
+        countingStream->write((uint64_t*)&cgen_var_251, 1 * 8);
+        uint64_t cgen_var_252;
+        countingStream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_252, 1);
+        countingStream->write((uint64_t*)&cgen_var_252, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_253 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_253);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyBufferView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyBufferView = OP_vkDestroyBufferView;
+    stream->write(&opcode_vkDestroyBufferView, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyBufferView, sizeof(uint32_t));
+    uint64_t cgen_var_254;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_254, 1);
+    stream->write((uint64_t*)&cgen_var_254, 1 * 8);
+    uint64_t cgen_var_255;
+    stream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_255, 1);
+    stream->write((uint64_t*)&cgen_var_255, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_256 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_256);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkBufferView((VkBufferView*)&bufferView);
+}
+
+VkResult VkEncoder::vkCreateImage(
+    VkDevice device,
+    const VkImageCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkImage* pImage)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImageCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkImageCreateInfo*)pool->alloc(sizeof(const VkImageCreateInfo));
+        deepcopy_VkImageCreateInfo(pool, pCreateInfo, (VkImageCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    goldfish_unwrap_VkNativeBufferANDROID(pCreateInfo, local_pCreateInfo);
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_257;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_257, 1);
+        countingStream->write((uint64_t*)&cgen_var_257, 1 * 8);
+        marshal_VkImageCreateInfo(countingStream, (VkImageCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_258 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_258);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_259;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_259, 1);
+        countingStream->write((uint64_t*)&cgen_var_259, 8);
+    }
+    uint32_t packetSize_vkCreateImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateImage = OP_vkCreateImage;
+    stream->write(&opcode_vkCreateImage, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateImage, sizeof(uint32_t));
+    uint64_t cgen_var_260;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_260, 1);
+    stream->write((uint64_t*)&cgen_var_260, 1 * 8);
+    marshal_VkImageCreateInfo(stream, (VkImageCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_261 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_261);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_262;
+    stream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_262, 1);
+    stream->write((uint64_t*)&cgen_var_262, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_263;
+    stream->read((uint64_t*)&cgen_var_263, 8);
+    stream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_263, (VkImage*)pImage, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateImage_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateImage_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateImage_VkResult_return;
+}
+
+void VkEncoder::vkDestroyImage(
+    VkDevice device,
+    VkImage image,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImage local_image;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_image = image;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_264;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_264, 1);
+        countingStream->write((uint64_t*)&cgen_var_264, 1 * 8);
+        uint64_t cgen_var_265;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_265, 1);
+        countingStream->write((uint64_t*)&cgen_var_265, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_266 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_266);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyImage = OP_vkDestroyImage;
+    stream->write(&opcode_vkDestroyImage, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyImage, sizeof(uint32_t));
+    uint64_t cgen_var_267;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_267, 1);
+    stream->write((uint64_t*)&cgen_var_267, 1 * 8);
+    uint64_t cgen_var_268;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_268, 1);
+    stream->write((uint64_t*)&cgen_var_268, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_269 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_269);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkImage((VkImage*)&image);
+}
+
+void VkEncoder::vkGetImageSubresourceLayout(
+    VkDevice device,
+    VkImage image,
+    const VkImageSubresource* pSubresource,
+    VkSubresourceLayout* pLayout)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImage local_image;
+    VkImageSubresource* local_pSubresource;
+    local_device = device;
+    local_image = image;
+    local_pSubresource = nullptr;
+    if (pSubresource)
+    {
+        local_pSubresource = (VkImageSubresource*)pool->alloc(sizeof(const VkImageSubresource));
+        deepcopy_VkImageSubresource(pool, pSubresource, (VkImageSubresource*)(local_pSubresource));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_270;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_270, 1);
+        countingStream->write((uint64_t*)&cgen_var_270, 1 * 8);
+        uint64_t cgen_var_271;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_271, 1);
+        countingStream->write((uint64_t*)&cgen_var_271, 1 * 8);
+        marshal_VkImageSubresource(countingStream, (VkImageSubresource*)(local_pSubresource));
+        marshal_VkSubresourceLayout(countingStream, (VkSubresourceLayout*)(pLayout));
+    }
+    uint32_t packetSize_vkGetImageSubresourceLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetImageSubresourceLayout = OP_vkGetImageSubresourceLayout;
+    stream->write(&opcode_vkGetImageSubresourceLayout, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetImageSubresourceLayout, sizeof(uint32_t));
+    uint64_t cgen_var_272;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_272, 1);
+    stream->write((uint64_t*)&cgen_var_272, 1 * 8);
+    uint64_t cgen_var_273;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_273, 1);
+    stream->write((uint64_t*)&cgen_var_273, 1 * 8);
+    marshal_VkImageSubresource(stream, (VkImageSubresource*)(local_pSubresource));
+    marshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout));
+    unmarshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout));
+}
+
+VkResult VkEncoder::vkCreateImageView(
+    VkDevice device,
+    const VkImageViewCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkImageView* pView)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImageViewCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkImageViewCreateInfo*)pool->alloc(sizeof(const VkImageViewCreateInfo));
+        deepcopy_VkImageViewCreateInfo(pool, pCreateInfo, (VkImageViewCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_274;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_274, 1);
+        countingStream->write((uint64_t*)&cgen_var_274, 1 * 8);
+        marshal_VkImageViewCreateInfo(countingStream, (VkImageViewCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_275 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_275);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_276;
+        countingStream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_276, 1);
+        countingStream->write((uint64_t*)&cgen_var_276, 8);
+    }
+    uint32_t packetSize_vkCreateImageView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateImageView = OP_vkCreateImageView;
+    stream->write(&opcode_vkCreateImageView, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateImageView, sizeof(uint32_t));
+    uint64_t cgen_var_277;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_277, 1);
+    stream->write((uint64_t*)&cgen_var_277, 1 * 8);
+    marshal_VkImageViewCreateInfo(stream, (VkImageViewCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_278 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_278);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_279;
+    stream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_279, 1);
+    stream->write((uint64_t*)&cgen_var_279, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_280;
+    stream->read((uint64_t*)&cgen_var_280, 8);
+    stream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_280, (VkImageView*)pView, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateImageView_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateImageView_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateImageView_VkResult_return;
+}
+
+void VkEncoder::vkDestroyImageView(
+    VkDevice device,
+    VkImageView imageView,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImageView local_imageView;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_imageView = imageView;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_281;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_281, 1);
+        countingStream->write((uint64_t*)&cgen_var_281, 1 * 8);
+        uint64_t cgen_var_282;
+        countingStream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_282, 1);
+        countingStream->write((uint64_t*)&cgen_var_282, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_283 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_283);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyImageView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyImageView = OP_vkDestroyImageView;
+    stream->write(&opcode_vkDestroyImageView, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyImageView, sizeof(uint32_t));
+    uint64_t cgen_var_284;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_284, 1);
+    stream->write((uint64_t*)&cgen_var_284, 1 * 8);
+    uint64_t cgen_var_285;
+    stream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_285, 1);
+    stream->write((uint64_t*)&cgen_var_285, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_286 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_286);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkImageView((VkImageView*)&imageView);
+}
+
+VkResult VkEncoder::vkCreateShaderModule(
+    VkDevice device,
+    const VkShaderModuleCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkShaderModule* pShaderModule)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkShaderModuleCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkShaderModuleCreateInfo*)pool->alloc(sizeof(const VkShaderModuleCreateInfo));
+        deepcopy_VkShaderModuleCreateInfo(pool, pCreateInfo, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_287;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_287, 1);
+        countingStream->write((uint64_t*)&cgen_var_287, 1 * 8);
+        marshal_VkShaderModuleCreateInfo(countingStream, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_288 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_288);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_289;
+        countingStream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_289, 1);
+        countingStream->write((uint64_t*)&cgen_var_289, 8);
+    }
+    uint32_t packetSize_vkCreateShaderModule = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateShaderModule = OP_vkCreateShaderModule;
+    stream->write(&opcode_vkCreateShaderModule, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateShaderModule, sizeof(uint32_t));
+    uint64_t cgen_var_290;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_290, 1);
+    stream->write((uint64_t*)&cgen_var_290, 1 * 8);
+    marshal_VkShaderModuleCreateInfo(stream, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_291 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_291);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_292;
+    stream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_292, 1);
+    stream->write((uint64_t*)&cgen_var_292, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_293;
+    stream->read((uint64_t*)&cgen_var_293, 8);
+    stream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_293, (VkShaderModule*)pShaderModule, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateShaderModule_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateShaderModule_VkResult_return;
+}
+
+void VkEncoder::vkDestroyShaderModule(
+    VkDevice device,
+    VkShaderModule shaderModule,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkShaderModule local_shaderModule;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_shaderModule = shaderModule;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_294;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_294, 1);
+        countingStream->write((uint64_t*)&cgen_var_294, 1 * 8);
+        uint64_t cgen_var_295;
+        countingStream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_295, 1);
+        countingStream->write((uint64_t*)&cgen_var_295, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_296 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_296);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyShaderModule = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyShaderModule = OP_vkDestroyShaderModule;
+    stream->write(&opcode_vkDestroyShaderModule, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyShaderModule, sizeof(uint32_t));
+    uint64_t cgen_var_297;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_297, 1);
+    stream->write((uint64_t*)&cgen_var_297, 1 * 8);
+    uint64_t cgen_var_298;
+    stream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_298, 1);
+    stream->write((uint64_t*)&cgen_var_298, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_299 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_299);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkShaderModule((VkShaderModule*)&shaderModule);
+}
+
+VkResult VkEncoder::vkCreatePipelineCache(
+    VkDevice device,
+    const VkPipelineCacheCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkPipelineCache* pPipelineCache)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkPipelineCacheCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkPipelineCacheCreateInfo*)pool->alloc(sizeof(const VkPipelineCacheCreateInfo));
+        deepcopy_VkPipelineCacheCreateInfo(pool, pCreateInfo, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_300;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_300, 1);
+        countingStream->write((uint64_t*)&cgen_var_300, 1 * 8);
+        marshal_VkPipelineCacheCreateInfo(countingStream, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_301 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_301);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_302;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_302, 1);
+        countingStream->write((uint64_t*)&cgen_var_302, 8);
+    }
+    uint32_t packetSize_vkCreatePipelineCache = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreatePipelineCache = OP_vkCreatePipelineCache;
+    stream->write(&opcode_vkCreatePipelineCache, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreatePipelineCache, sizeof(uint32_t));
+    uint64_t cgen_var_303;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_303, 1);
+    stream->write((uint64_t*)&cgen_var_303, 1 * 8);
+    marshal_VkPipelineCacheCreateInfo(stream, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_304 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_304);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_305;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_305, 1);
+    stream->write((uint64_t*)&cgen_var_305, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_306;
+    stream->read((uint64_t*)&cgen_var_306, 8);
+    stream->handleMapping()->mapHandles_u64_VkPipelineCache(&cgen_var_306, (VkPipelineCache*)pPipelineCache, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
+    stream->read(&vkCreatePipelineCache_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreatePipelineCache_VkResult_return;
+}
+
+void VkEncoder::vkDestroyPipelineCache(
+    VkDevice device,
+    VkPipelineCache pipelineCache,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkPipelineCache local_pipelineCache;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pipelineCache = pipelineCache;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_307;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_307, 1);
+        countingStream->write((uint64_t*)&cgen_var_307, 1 * 8);
+        uint64_t cgen_var_308;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_308, 1);
+        countingStream->write((uint64_t*)&cgen_var_308, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_309 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_309);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyPipelineCache = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyPipelineCache = OP_vkDestroyPipelineCache;
+    stream->write(&opcode_vkDestroyPipelineCache, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyPipelineCache, sizeof(uint32_t));
+    uint64_t cgen_var_310;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_310, 1);
+    stream->write((uint64_t*)&cgen_var_310, 1 * 8);
+    uint64_t cgen_var_311;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_311, 1);
+    stream->write((uint64_t*)&cgen_var_311, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_312 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_312);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkPipelineCache((VkPipelineCache*)&pipelineCache);
+}
+
+VkResult VkEncoder::vkGetPipelineCacheData(
+    VkDevice device,
+    VkPipelineCache pipelineCache,
+    size_t* pDataSize,
+    void* pData)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkPipelineCache local_pipelineCache;
+    local_device = device;
+    local_pipelineCache = pipelineCache;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_313;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_313, 1);
+        countingStream->write((uint64_t*)&cgen_var_313, 1 * 8);
+        uint64_t cgen_var_314;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_314, 1);
+        countingStream->write((uint64_t*)&cgen_var_314, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_315 = (uint64_t)(uintptr_t)pDataSize;
+        countingStream->putBe64(cgen_var_315);
+        if (pDataSize)
+        {
+            uint64_t cgen_var_316 = (uint64_t)(*pDataSize);
+            countingStream->putBe64(cgen_var_316);
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_317 = (uint64_t)(uintptr_t)pData;
+        countingStream->putBe64(cgen_var_317);
+        if (pData)
+        {
+            countingStream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+        }
+    }
+    uint32_t packetSize_vkGetPipelineCacheData = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPipelineCacheData = OP_vkGetPipelineCacheData;
+    stream->write(&opcode_vkGetPipelineCacheData, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPipelineCacheData, sizeof(uint32_t));
+    uint64_t cgen_var_318;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_318, 1);
+    stream->write((uint64_t*)&cgen_var_318, 1 * 8);
+    uint64_t cgen_var_319;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_319, 1);
+    stream->write((uint64_t*)&cgen_var_319, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_320 = (uint64_t)(uintptr_t)pDataSize;
+    stream->putBe64(cgen_var_320);
+    if (pDataSize)
+    {
+        uint64_t cgen_var_321 = (uint64_t)(*pDataSize);
+        stream->putBe64(cgen_var_321);
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_322 = (uint64_t)(uintptr_t)pData;
+    stream->putBe64(cgen_var_322);
+    if (pData)
+    {
+        stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+    }
+    // WARNING PTR CHECK
+    size_t* check_pDataSize;
+    check_pDataSize = (size_t*)(uintptr_t)stream->getBe64();
+    if (pDataSize)
+    {
+        if (!(check_pDataSize))
+        {
+            fprintf(stderr, "fatal: pDataSize inconsistent between guest and host\n");
+        }
+        (*pDataSize) = (size_t)stream->getBe64();
+    }
+    // WARNING PTR CHECK
+    void* check_pData;
+    check_pData = (void*)(uintptr_t)stream->getBe64();
+    if (pData)
+    {
+        if (!(check_pData))
+        {
+            fprintf(stderr, "fatal: pData inconsistent between guest and host\n");
+        }
+        stream->read((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+    }
+    VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPipelineCacheData_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPipelineCacheData_VkResult_return;
+}
+
+VkResult VkEncoder::vkMergePipelineCaches(
+    VkDevice device,
+    VkPipelineCache dstCache,
+    uint32_t srcCacheCount,
+    const VkPipelineCache* pSrcCaches)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkPipelineCache local_dstCache;
+    uint32_t local_srcCacheCount;
+    VkPipelineCache* local_pSrcCaches;
+    local_device = device;
+    local_dstCache = dstCache;
+    local_srcCacheCount = srcCacheCount;
+    local_pSrcCaches = nullptr;
+    if (pSrcCaches)
+    {
+        local_pSrcCaches = (VkPipelineCache*)pool->dupArray(pSrcCaches, ((srcCacheCount)) * sizeof(const VkPipelineCache));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_326;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_326, 1);
+        countingStream->write((uint64_t*)&cgen_var_326, 1 * 8);
+        uint64_t cgen_var_327;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_327, 1);
+        countingStream->write((uint64_t*)&cgen_var_327, 1 * 8);
+        countingStream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
+        if (((srcCacheCount)))
+        {
+            uint64_t* cgen_var_328;
+            countingStream->alloc((void**)&cgen_var_328, ((srcCacheCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_328, ((srcCacheCount)));
+            countingStream->write((uint64_t*)cgen_var_328, ((srcCacheCount)) * 8);
+        }
+    }
+    uint32_t packetSize_vkMergePipelineCaches = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkMergePipelineCaches = OP_vkMergePipelineCaches;
+    stream->write(&opcode_vkMergePipelineCaches, sizeof(uint32_t));
+    stream->write(&packetSize_vkMergePipelineCaches, sizeof(uint32_t));
+    uint64_t cgen_var_329;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_329, 1);
+    stream->write((uint64_t*)&cgen_var_329, 1 * 8);
+    uint64_t cgen_var_330;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_330, 1);
+    stream->write((uint64_t*)&cgen_var_330, 1 * 8);
+    stream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
+    if (((srcCacheCount)))
+    {
+        uint64_t* cgen_var_331;
+        stream->alloc((void**)&cgen_var_331, ((srcCacheCount)) * 8);
+        stream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_331, ((srcCacheCount)));
+        stream->write((uint64_t*)cgen_var_331, ((srcCacheCount)) * 8);
+    }
+    VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
+    stream->read(&vkMergePipelineCaches_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkMergePipelineCaches_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateGraphicsPipelines(
+    VkDevice device,
+    VkPipelineCache pipelineCache,
+    uint32_t createInfoCount,
+    const VkGraphicsPipelineCreateInfo* pCreateInfos,
+    const VkAllocationCallbacks* pAllocator,
+    VkPipeline* pPipelines)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkPipelineCache local_pipelineCache;
+    uint32_t local_createInfoCount;
+    VkGraphicsPipelineCreateInfo* local_pCreateInfos;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pipelineCache = pipelineCache;
+    local_createInfoCount = createInfoCount;
+    local_pCreateInfos = nullptr;
+    if (pCreateInfos)
+    {
+        local_pCreateInfos = (VkGraphicsPipelineCreateInfo*)pool->alloc(((createInfoCount)) * sizeof(const VkGraphicsPipelineCreateInfo));
+        for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+        {
+            deepcopy_VkGraphicsPipelineCreateInfo(pool, pCreateInfos + i, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
+        }
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_332;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_332, 1);
+        countingStream->write((uint64_t*)&cgen_var_332, 1 * 8);
+        uint64_t cgen_var_333;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_333, 1);
+        countingStream->write((uint64_t*)&cgen_var_333, 1 * 8);
+        countingStream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+        {
+            marshal_VkGraphicsPipelineCreateInfo(countingStream, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_334 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_334);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        if (((createInfoCount)))
+        {
+            uint64_t* cgen_var_335;
+            countingStream->alloc((void**)&cgen_var_335, ((createInfoCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_335, ((createInfoCount)));
+            countingStream->write((uint64_t*)cgen_var_335, ((createInfoCount)) * 8);
+        }
+    }
+    uint32_t packetSize_vkCreateGraphicsPipelines = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateGraphicsPipelines = OP_vkCreateGraphicsPipelines;
+    stream->write(&opcode_vkCreateGraphicsPipelines, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateGraphicsPipelines, sizeof(uint32_t));
+    uint64_t cgen_var_336;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_336, 1);
+    stream->write((uint64_t*)&cgen_var_336, 1 * 8);
+    uint64_t cgen_var_337;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_337, 1);
+    stream->write((uint64_t*)&cgen_var_337, 1 * 8);
+    stream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+    {
+        marshal_VkGraphicsPipelineCreateInfo(stream, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_338 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_338);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    if (((createInfoCount)))
+    {
+        uint64_t* cgen_var_339;
+        stream->alloc((void**)&cgen_var_339, ((createInfoCount)) * 8);
+        stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_339, ((createInfoCount)));
+        stream->write((uint64_t*)cgen_var_339, ((createInfoCount)) * 8);
+    }
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    if (((createInfoCount)))
+    {
+        uint64_t* cgen_var_340;
+        stream->alloc((void**)&cgen_var_340, ((createInfoCount)) * 8);
+        stream->read((uint64_t*)cgen_var_340, ((createInfoCount)) * 8);
+        stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_340, (VkPipeline*)pPipelines, ((createInfoCount)));
+    }
+    stream->unsetHandleMapping();
+    VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateGraphicsPipelines_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateGraphicsPipelines_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateComputePipelines(
+    VkDevice device,
+    VkPipelineCache pipelineCache,
+    uint32_t createInfoCount,
+    const VkComputePipelineCreateInfo* pCreateInfos,
+    const VkAllocationCallbacks* pAllocator,
+    VkPipeline* pPipelines)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkPipelineCache local_pipelineCache;
+    uint32_t local_createInfoCount;
+    VkComputePipelineCreateInfo* local_pCreateInfos;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pipelineCache = pipelineCache;
+    local_createInfoCount = createInfoCount;
+    local_pCreateInfos = nullptr;
+    if (pCreateInfos)
+    {
+        local_pCreateInfos = (VkComputePipelineCreateInfo*)pool->alloc(((createInfoCount)) * sizeof(const VkComputePipelineCreateInfo));
+        for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+        {
+            deepcopy_VkComputePipelineCreateInfo(pool, pCreateInfos + i, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
+        }
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_341;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_341, 1);
+        countingStream->write((uint64_t*)&cgen_var_341, 1 * 8);
+        uint64_t cgen_var_342;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_342, 1);
+        countingStream->write((uint64_t*)&cgen_var_342, 1 * 8);
+        countingStream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+        {
+            marshal_VkComputePipelineCreateInfo(countingStream, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_343 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_343);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        if (((createInfoCount)))
+        {
+            uint64_t* cgen_var_344;
+            countingStream->alloc((void**)&cgen_var_344, ((createInfoCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_344, ((createInfoCount)));
+            countingStream->write((uint64_t*)cgen_var_344, ((createInfoCount)) * 8);
+        }
+    }
+    uint32_t packetSize_vkCreateComputePipelines = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateComputePipelines = OP_vkCreateComputePipelines;
+    stream->write(&opcode_vkCreateComputePipelines, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateComputePipelines, sizeof(uint32_t));
+    uint64_t cgen_var_345;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_345, 1);
+    stream->write((uint64_t*)&cgen_var_345, 1 * 8);
+    uint64_t cgen_var_346;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_346, 1);
+    stream->write((uint64_t*)&cgen_var_346, 1 * 8);
+    stream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+    {
+        marshal_VkComputePipelineCreateInfo(stream, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_347 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_347);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    if (((createInfoCount)))
+    {
+        uint64_t* cgen_var_348;
+        stream->alloc((void**)&cgen_var_348, ((createInfoCount)) * 8);
+        stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_348, ((createInfoCount)));
+        stream->write((uint64_t*)cgen_var_348, ((createInfoCount)) * 8);
+    }
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    if (((createInfoCount)))
+    {
+        uint64_t* cgen_var_349;
+        stream->alloc((void**)&cgen_var_349, ((createInfoCount)) * 8);
+        stream->read((uint64_t*)cgen_var_349, ((createInfoCount)) * 8);
+        stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_349, (VkPipeline*)pPipelines, ((createInfoCount)));
+    }
+    stream->unsetHandleMapping();
+    VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateComputePipelines_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateComputePipelines_VkResult_return;
+}
+
+void VkEncoder::vkDestroyPipeline(
+    VkDevice device,
+    VkPipeline pipeline,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkPipeline local_pipeline;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pipeline = pipeline;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_350;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_350, 1);
+        countingStream->write((uint64_t*)&cgen_var_350, 1 * 8);
+        uint64_t cgen_var_351;
+        countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_351, 1);
+        countingStream->write((uint64_t*)&cgen_var_351, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_352 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_352);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyPipeline = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyPipeline = OP_vkDestroyPipeline;
+    stream->write(&opcode_vkDestroyPipeline, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyPipeline, sizeof(uint32_t));
+    uint64_t cgen_var_353;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_353, 1);
+    stream->write((uint64_t*)&cgen_var_353, 1 * 8);
+    uint64_t cgen_var_354;
+    stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_354, 1);
+    stream->write((uint64_t*)&cgen_var_354, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_355 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_355);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkPipeline((VkPipeline*)&pipeline);
+}
+
+VkResult VkEncoder::vkCreatePipelineLayout(
+    VkDevice device,
+    const VkPipelineLayoutCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkPipelineLayout* pPipelineLayout)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkPipelineLayoutCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkPipelineLayoutCreateInfo*)pool->alloc(sizeof(const VkPipelineLayoutCreateInfo));
+        deepcopy_VkPipelineLayoutCreateInfo(pool, pCreateInfo, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_356;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_356, 1);
+        countingStream->write((uint64_t*)&cgen_var_356, 1 * 8);
+        marshal_VkPipelineLayoutCreateInfo(countingStream, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_357 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_357);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_358;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_358, 1);
+        countingStream->write((uint64_t*)&cgen_var_358, 8);
+    }
+    uint32_t packetSize_vkCreatePipelineLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreatePipelineLayout = OP_vkCreatePipelineLayout;
+    stream->write(&opcode_vkCreatePipelineLayout, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreatePipelineLayout, sizeof(uint32_t));
+    uint64_t cgen_var_359;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_359, 1);
+    stream->write((uint64_t*)&cgen_var_359, 1 * 8);
+    marshal_VkPipelineLayoutCreateInfo(stream, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_360 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_360);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_361;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_361, 1);
+    stream->write((uint64_t*)&cgen_var_361, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_362;
+    stream->read((uint64_t*)&cgen_var_362, 8);
+    stream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_362, (VkPipelineLayout*)pPipelineLayout, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
+    stream->read(&vkCreatePipelineLayout_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreatePipelineLayout_VkResult_return;
+}
+
+void VkEncoder::vkDestroyPipelineLayout(
+    VkDevice device,
+    VkPipelineLayout pipelineLayout,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkPipelineLayout local_pipelineLayout;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pipelineLayout = pipelineLayout;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_363;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_363, 1);
+        countingStream->write((uint64_t*)&cgen_var_363, 1 * 8);
+        uint64_t cgen_var_364;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_364, 1);
+        countingStream->write((uint64_t*)&cgen_var_364, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_365 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_365);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyPipelineLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyPipelineLayout = OP_vkDestroyPipelineLayout;
+    stream->write(&opcode_vkDestroyPipelineLayout, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyPipelineLayout, sizeof(uint32_t));
+    uint64_t cgen_var_366;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_366, 1);
+    stream->write((uint64_t*)&cgen_var_366, 1 * 8);
+    uint64_t cgen_var_367;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_367, 1);
+    stream->write((uint64_t*)&cgen_var_367, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_368 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_368);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkPipelineLayout((VkPipelineLayout*)&pipelineLayout);
+}
+
+VkResult VkEncoder::vkCreateSampler(
+    VkDevice device,
+    const VkSamplerCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSampler* pSampler)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSamplerCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkSamplerCreateInfo*)pool->alloc(sizeof(const VkSamplerCreateInfo));
+        deepcopy_VkSamplerCreateInfo(pool, pCreateInfo, (VkSamplerCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_369;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_369, 1);
+        countingStream->write((uint64_t*)&cgen_var_369, 1 * 8);
+        marshal_VkSamplerCreateInfo(countingStream, (VkSamplerCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_370 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_370);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_371;
+        countingStream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_371, 1);
+        countingStream->write((uint64_t*)&cgen_var_371, 8);
+    }
+    uint32_t packetSize_vkCreateSampler = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateSampler = OP_vkCreateSampler;
+    stream->write(&opcode_vkCreateSampler, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateSampler, sizeof(uint32_t));
+    uint64_t cgen_var_372;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_372, 1);
+    stream->write((uint64_t*)&cgen_var_372, 1 * 8);
+    marshal_VkSamplerCreateInfo(stream, (VkSamplerCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_373 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_373);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_374;
+    stream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_374, 1);
+    stream->write((uint64_t*)&cgen_var_374, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_375;
+    stream->read((uint64_t*)&cgen_var_375, 8);
+    stream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_375, (VkSampler*)pSampler, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateSampler_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateSampler_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateSampler_VkResult_return;
+}
+
+void VkEncoder::vkDestroySampler(
+    VkDevice device,
+    VkSampler sampler,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSampler local_sampler;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_sampler = sampler;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_376;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_376, 1);
+        countingStream->write((uint64_t*)&cgen_var_376, 1 * 8);
+        uint64_t cgen_var_377;
+        countingStream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_377, 1);
+        countingStream->write((uint64_t*)&cgen_var_377, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_378 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_378);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroySampler = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroySampler = OP_vkDestroySampler;
+    stream->write(&opcode_vkDestroySampler, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroySampler, sizeof(uint32_t));
+    uint64_t cgen_var_379;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_379, 1);
+    stream->write((uint64_t*)&cgen_var_379, 1 * 8);
+    uint64_t cgen_var_380;
+    stream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_380, 1);
+    stream->write((uint64_t*)&cgen_var_380, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_381 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_381);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkSampler((VkSampler*)&sampler);
+}
+
+VkResult VkEncoder::vkCreateDescriptorSetLayout(
+    VkDevice device,
+    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDescriptorSetLayout* pSetLayout)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorSetLayoutCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
+        deepcopy_VkDescriptorSetLayoutCreateInfo(pool, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_382;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_382, 1);
+        countingStream->write((uint64_t*)&cgen_var_382, 1 * 8);
+        marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_383 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_383);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_384;
+        countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_384, 1);
+        countingStream->write((uint64_t*)&cgen_var_384, 8);
+    }
+    uint32_t packetSize_vkCreateDescriptorSetLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateDescriptorSetLayout = OP_vkCreateDescriptorSetLayout;
+    stream->write(&opcode_vkCreateDescriptorSetLayout, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateDescriptorSetLayout, sizeof(uint32_t));
+    uint64_t cgen_var_385;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_385, 1);
+    stream->write((uint64_t*)&cgen_var_385, 1 * 8);
+    marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_386 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_386);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_387;
+    stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_387, 1);
+    stream->write((uint64_t*)&cgen_var_387, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_388;
+    stream->read((uint64_t*)&cgen_var_388, 8);
+    stream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_388, (VkDescriptorSetLayout*)pSetLayout, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateDescriptorSetLayout_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateDescriptorSetLayout_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDescriptorSetLayout(
+    VkDevice device,
+    VkDescriptorSetLayout descriptorSetLayout,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorSetLayout local_descriptorSetLayout;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_descriptorSetLayout = descriptorSetLayout;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_389;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_389, 1);
+        countingStream->write((uint64_t*)&cgen_var_389, 1 * 8);
+        uint64_t cgen_var_390;
+        countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_390, 1);
+        countingStream->write((uint64_t*)&cgen_var_390, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_391 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_391);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyDescriptorSetLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyDescriptorSetLayout = OP_vkDestroyDescriptorSetLayout;
+    stream->write(&opcode_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
+    uint64_t cgen_var_392;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_392, 1);
+    stream->write((uint64_t*)&cgen_var_392, 1 * 8);
+    uint64_t cgen_var_393;
+    stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_393, 1);
+    stream->write((uint64_t*)&cgen_var_393, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_394 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_394);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&descriptorSetLayout);
+}
+
+VkResult VkEncoder::vkCreateDescriptorPool(
+    VkDevice device,
+    const VkDescriptorPoolCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDescriptorPool* pDescriptorPool)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorPoolCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDescriptorPoolCreateInfo*)pool->alloc(sizeof(const VkDescriptorPoolCreateInfo));
+        deepcopy_VkDescriptorPoolCreateInfo(pool, pCreateInfo, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_395;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_395, 1);
+        countingStream->write((uint64_t*)&cgen_var_395, 1 * 8);
+        marshal_VkDescriptorPoolCreateInfo(countingStream, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_396 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_396);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_397;
+        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_397, 1);
+        countingStream->write((uint64_t*)&cgen_var_397, 8);
+    }
+    uint32_t packetSize_vkCreateDescriptorPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateDescriptorPool = OP_vkCreateDescriptorPool;
+    stream->write(&opcode_vkCreateDescriptorPool, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateDescriptorPool, sizeof(uint32_t));
+    uint64_t cgen_var_398;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_398, 1);
+    stream->write((uint64_t*)&cgen_var_398, 1 * 8);
+    marshal_VkDescriptorPoolCreateInfo(stream, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_399 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_399);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_400;
+    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_400, 1);
+    stream->write((uint64_t*)&cgen_var_400, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_401;
+    stream->read((uint64_t*)&cgen_var_401, 8);
+    stream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_401, (VkDescriptorPool*)pDescriptorPool, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateDescriptorPool_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateDescriptorPool_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDescriptorPool(
+    VkDevice device,
+    VkDescriptorPool descriptorPool,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorPool local_descriptorPool;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_descriptorPool = descriptorPool;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_402;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_402, 1);
+        countingStream->write((uint64_t*)&cgen_var_402, 1 * 8);
+        uint64_t cgen_var_403;
+        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_403, 1);
+        countingStream->write((uint64_t*)&cgen_var_403, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_404 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_404);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyDescriptorPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyDescriptorPool = OP_vkDestroyDescriptorPool;
+    stream->write(&opcode_vkDestroyDescriptorPool, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyDescriptorPool, sizeof(uint32_t));
+    uint64_t cgen_var_405;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_405, 1);
+    stream->write((uint64_t*)&cgen_var_405, 1 * 8);
+    uint64_t cgen_var_406;
+    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_406, 1);
+    stream->write((uint64_t*)&cgen_var_406, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_407 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_407);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkDescriptorPool((VkDescriptorPool*)&descriptorPool);
+}
+
+VkResult VkEncoder::vkResetDescriptorPool(
+    VkDevice device,
+    VkDescriptorPool descriptorPool,
+    VkDescriptorPoolResetFlags flags)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorPool local_descriptorPool;
+    VkDescriptorPoolResetFlags local_flags;
+    local_device = device;
+    local_descriptorPool = descriptorPool;
+    local_flags = flags;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_408;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_408, 1);
+        countingStream->write((uint64_t*)&cgen_var_408, 1 * 8);
+        uint64_t cgen_var_409;
+        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_409, 1);
+        countingStream->write((uint64_t*)&cgen_var_409, 1 * 8);
+        countingStream->write((VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags));
+    }
+    uint32_t packetSize_vkResetDescriptorPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkResetDescriptorPool = OP_vkResetDescriptorPool;
+    stream->write(&opcode_vkResetDescriptorPool, sizeof(uint32_t));
+    stream->write(&packetSize_vkResetDescriptorPool, sizeof(uint32_t));
+    uint64_t cgen_var_410;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_410, 1);
+    stream->write((uint64_t*)&cgen_var_410, 1 * 8);
+    uint64_t cgen_var_411;
+    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_411, 1);
+    stream->write((uint64_t*)&cgen_var_411, 1 * 8);
+    stream->write((VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags));
+    VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
+    stream->read(&vkResetDescriptorPool_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkResetDescriptorPool_VkResult_return;
+}
+
+VkResult VkEncoder::vkAllocateDescriptorSets(
+    VkDevice device,
+    const VkDescriptorSetAllocateInfo* pAllocateInfo,
+    VkDescriptorSet* pDescriptorSets)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorSetAllocateInfo* local_pAllocateInfo;
+    local_device = device;
+    local_pAllocateInfo = nullptr;
+    if (pAllocateInfo)
+    {
+        local_pAllocateInfo = (VkDescriptorSetAllocateInfo*)pool->alloc(sizeof(const VkDescriptorSetAllocateInfo));
+        deepcopy_VkDescriptorSetAllocateInfo(pool, pAllocateInfo, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_412;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_412, 1);
+        countingStream->write((uint64_t*)&cgen_var_412, 1 * 8);
+        marshal_VkDescriptorSetAllocateInfo(countingStream, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
+        if (pAllocateInfo->descriptorSetCount)
+        {
+            uint64_t* cgen_var_413;
+            countingStream->alloc((void**)&cgen_var_413, pAllocateInfo->descriptorSetCount * 8);
+            countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_413, pAllocateInfo->descriptorSetCount);
+            countingStream->write((uint64_t*)cgen_var_413, pAllocateInfo->descriptorSetCount * 8);
+        }
+    }
+    uint32_t packetSize_vkAllocateDescriptorSets = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkAllocateDescriptorSets = OP_vkAllocateDescriptorSets;
+    stream->write(&opcode_vkAllocateDescriptorSets, sizeof(uint32_t));
+    stream->write(&packetSize_vkAllocateDescriptorSets, sizeof(uint32_t));
+    uint64_t cgen_var_414;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_414, 1);
+    stream->write((uint64_t*)&cgen_var_414, 1 * 8);
+    marshal_VkDescriptorSetAllocateInfo(stream, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    if (pAllocateInfo->descriptorSetCount)
+    {
+        uint64_t* cgen_var_415;
+        stream->alloc((void**)&cgen_var_415, pAllocateInfo->descriptorSetCount * 8);
+        stream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_415, pAllocateInfo->descriptorSetCount);
+        stream->write((uint64_t*)cgen_var_415, pAllocateInfo->descriptorSetCount * 8);
+    }
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    if (pAllocateInfo->descriptorSetCount)
+    {
+        uint64_t* cgen_var_416;
+        stream->alloc((void**)&cgen_var_416, pAllocateInfo->descriptorSetCount * 8);
+        stream->read((uint64_t*)cgen_var_416, pAllocateInfo->descriptorSetCount * 8);
+        stream->handleMapping()->mapHandles_u64_VkDescriptorSet(cgen_var_416, (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
+    }
+    stream->unsetHandleMapping();
+    VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
+    stream->read(&vkAllocateDescriptorSets_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkAllocateDescriptorSets_VkResult_return;
+}
+
+VkResult VkEncoder::vkFreeDescriptorSets(
+    VkDevice device,
+    VkDescriptorPool descriptorPool,
+    uint32_t descriptorSetCount,
+    const VkDescriptorSet* pDescriptorSets)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorPool local_descriptorPool;
+    uint32_t local_descriptorSetCount;
+    VkDescriptorSet* local_pDescriptorSets;
+    local_device = device;
+    local_descriptorPool = descriptorPool;
+    local_descriptorSetCount = descriptorSetCount;
+    local_pDescriptorSets = nullptr;
+    if (pDescriptorSets)
+    {
+        local_pDescriptorSets = (VkDescriptorSet*)pool->dupArray(pDescriptorSets, ((descriptorSetCount)) * sizeof(const VkDescriptorSet));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_417;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_417, 1);
+        countingStream->write((uint64_t*)&cgen_var_417, 1 * 8);
+        uint64_t cgen_var_418;
+        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_418, 1);
+        countingStream->write((uint64_t*)&cgen_var_418, 1 * 8);
+        countingStream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_419 = (uint64_t)(uintptr_t)local_pDescriptorSets;
+        countingStream->putBe64(cgen_var_419);
+        if (local_pDescriptorSets)
+        {
+            if (((descriptorSetCount)))
+            {
+                uint64_t* cgen_var_420;
+                countingStream->alloc((void**)&cgen_var_420, ((descriptorSetCount)) * 8);
+                countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_420, ((descriptorSetCount)));
+                countingStream->write((uint64_t*)cgen_var_420, ((descriptorSetCount)) * 8);
+            }
+        }
+    }
+    uint32_t packetSize_vkFreeDescriptorSets = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkFreeDescriptorSets = OP_vkFreeDescriptorSets;
+    stream->write(&opcode_vkFreeDescriptorSets, sizeof(uint32_t));
+    stream->write(&packetSize_vkFreeDescriptorSets, sizeof(uint32_t));
+    uint64_t cgen_var_421;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_421, 1);
+    stream->write((uint64_t*)&cgen_var_421, 1 * 8);
+    uint64_t cgen_var_422;
+    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_422, 1);
+    stream->write((uint64_t*)&cgen_var_422, 1 * 8);
+    stream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_423 = (uint64_t)(uintptr_t)local_pDescriptorSets;
+    stream->putBe64(cgen_var_423);
+    if (local_pDescriptorSets)
+    {
+        if (((descriptorSetCount)))
+        {
+            uint64_t* cgen_var_424;
+            stream->alloc((void**)&cgen_var_424, ((descriptorSetCount)) * 8);
+            stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_424, ((descriptorSetCount)));
+            stream->write((uint64_t*)cgen_var_424, ((descriptorSetCount)) * 8);
+        }
+    }
+    VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
+    stream->read(&vkFreeDescriptorSets_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    if (pDescriptorSets)
+    {
+        resources->destroyMapping()->mapHandles_VkDescriptorSet((VkDescriptorSet*)pDescriptorSets, ((descriptorSetCount)));
+    }
+    return vkFreeDescriptorSets_VkResult_return;
+}
+
+void VkEncoder::vkUpdateDescriptorSets(
+    VkDevice device,
+    uint32_t descriptorWriteCount,
+    const VkWriteDescriptorSet* pDescriptorWrites,
+    uint32_t descriptorCopyCount,
+    const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_descriptorWriteCount;
+    VkWriteDescriptorSet* local_pDescriptorWrites;
+    uint32_t local_descriptorCopyCount;
+    VkCopyDescriptorSet* local_pDescriptorCopies;
+    local_device = device;
+    local_descriptorWriteCount = descriptorWriteCount;
+    local_pDescriptorWrites = nullptr;
+    if (pDescriptorWrites)
+    {
+        local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
+        for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+        {
+            deepcopy_VkWriteDescriptorSet(pool, pDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+        }
+    }
+    local_descriptorCopyCount = descriptorCopyCount;
+    local_pDescriptorCopies = nullptr;
+    if (pDescriptorCopies)
+    {
+        local_pDescriptorCopies = (VkCopyDescriptorSet*)pool->alloc(((descriptorCopyCount)) * sizeof(const VkCopyDescriptorSet));
+        for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
+        {
+            deepcopy_VkCopyDescriptorSet(pool, pDescriptorCopies + i, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_425;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_425, 1);
+        countingStream->write((uint64_t*)&cgen_var_425, 1 * 8);
+        countingStream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+        {
+            marshal_VkWriteDescriptorSet(countingStream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+        }
+        countingStream->write((uint32_t*)&local_descriptorCopyCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
+        {
+            marshal_VkCopyDescriptorSet(countingStream, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
+        }
+    }
+    uint32_t packetSize_vkUpdateDescriptorSets = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkUpdateDescriptorSets = OP_vkUpdateDescriptorSets;
+    stream->write(&opcode_vkUpdateDescriptorSets, sizeof(uint32_t));
+    stream->write(&packetSize_vkUpdateDescriptorSets, sizeof(uint32_t));
+    uint64_t cgen_var_426;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_426, 1);
+    stream->write((uint64_t*)&cgen_var_426, 1 * 8);
+    stream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+    {
+        marshal_VkWriteDescriptorSet(stream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+    }
+    stream->write((uint32_t*)&local_descriptorCopyCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
+    {
+        marshal_VkCopyDescriptorSet(stream, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
+    }
+}
+
+VkResult VkEncoder::vkCreateFramebuffer(
+    VkDevice device,
+    const VkFramebufferCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkFramebuffer* pFramebuffer)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkFramebufferCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkFramebufferCreateInfo*)pool->alloc(sizeof(const VkFramebufferCreateInfo));
+        deepcopy_VkFramebufferCreateInfo(pool, pCreateInfo, (VkFramebufferCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_427;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_427, 1);
+        countingStream->write((uint64_t*)&cgen_var_427, 1 * 8);
+        marshal_VkFramebufferCreateInfo(countingStream, (VkFramebufferCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_428 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_428);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_429;
+        countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_429, 1);
+        countingStream->write((uint64_t*)&cgen_var_429, 8);
+    }
+    uint32_t packetSize_vkCreateFramebuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateFramebuffer = OP_vkCreateFramebuffer;
+    stream->write(&opcode_vkCreateFramebuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateFramebuffer, sizeof(uint32_t));
+    uint64_t cgen_var_430;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_430, 1);
+    stream->write((uint64_t*)&cgen_var_430, 1 * 8);
+    marshal_VkFramebufferCreateInfo(stream, (VkFramebufferCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_431 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_431);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_432;
+    stream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_432, 1);
+    stream->write((uint64_t*)&cgen_var_432, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_433;
+    stream->read((uint64_t*)&cgen_var_433, 8);
+    stream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_433, (VkFramebuffer*)pFramebuffer, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateFramebuffer_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateFramebuffer_VkResult_return;
+}
+
+void VkEncoder::vkDestroyFramebuffer(
+    VkDevice device,
+    VkFramebuffer framebuffer,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkFramebuffer local_framebuffer;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_framebuffer = framebuffer;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_434;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_434, 1);
+        countingStream->write((uint64_t*)&cgen_var_434, 1 * 8);
+        uint64_t cgen_var_435;
+        countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_435, 1);
+        countingStream->write((uint64_t*)&cgen_var_435, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_436 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_436);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyFramebuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyFramebuffer = OP_vkDestroyFramebuffer;
+    stream->write(&opcode_vkDestroyFramebuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyFramebuffer, sizeof(uint32_t));
+    uint64_t cgen_var_437;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_437, 1);
+    stream->write((uint64_t*)&cgen_var_437, 1 * 8);
+    uint64_t cgen_var_438;
+    stream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_438, 1);
+    stream->write((uint64_t*)&cgen_var_438, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_439 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_439);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkFramebuffer((VkFramebuffer*)&framebuffer);
+}
+
+VkResult VkEncoder::vkCreateRenderPass(
+    VkDevice device,
+    const VkRenderPassCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkRenderPass* pRenderPass)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkRenderPassCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkRenderPassCreateInfo*)pool->alloc(sizeof(const VkRenderPassCreateInfo));
+        deepcopy_VkRenderPassCreateInfo(pool, pCreateInfo, (VkRenderPassCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_440;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_440, 1);
+        countingStream->write((uint64_t*)&cgen_var_440, 1 * 8);
+        marshal_VkRenderPassCreateInfo(countingStream, (VkRenderPassCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_441 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_441);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_442;
+        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_442, 1);
+        countingStream->write((uint64_t*)&cgen_var_442, 8);
+    }
+    uint32_t packetSize_vkCreateRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateRenderPass = OP_vkCreateRenderPass;
+    stream->write(&opcode_vkCreateRenderPass, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateRenderPass, sizeof(uint32_t));
+    uint64_t cgen_var_443;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_443, 1);
+    stream->write((uint64_t*)&cgen_var_443, 1 * 8);
+    marshal_VkRenderPassCreateInfo(stream, (VkRenderPassCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_444 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_444);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_445;
+    stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_445, 1);
+    stream->write((uint64_t*)&cgen_var_445, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_446;
+    stream->read((uint64_t*)&cgen_var_446, 8);
+    stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_446, (VkRenderPass*)pRenderPass, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateRenderPass_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateRenderPass_VkResult_return;
+}
+
+void VkEncoder::vkDestroyRenderPass(
+    VkDevice device,
+    VkRenderPass renderPass,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkRenderPass local_renderPass;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_renderPass = renderPass;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_447;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_447, 1);
+        countingStream->write((uint64_t*)&cgen_var_447, 1 * 8);
+        uint64_t cgen_var_448;
+        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_448, 1);
+        countingStream->write((uint64_t*)&cgen_var_448, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_449 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_449);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyRenderPass = OP_vkDestroyRenderPass;
+    stream->write(&opcode_vkDestroyRenderPass, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyRenderPass, sizeof(uint32_t));
+    uint64_t cgen_var_450;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_450, 1);
+    stream->write((uint64_t*)&cgen_var_450, 1 * 8);
+    uint64_t cgen_var_451;
+    stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_451, 1);
+    stream->write((uint64_t*)&cgen_var_451, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_452 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_452);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkRenderPass((VkRenderPass*)&renderPass);
+}
+
+void VkEncoder::vkGetRenderAreaGranularity(
+    VkDevice device,
+    VkRenderPass renderPass,
+    VkExtent2D* pGranularity)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkRenderPass local_renderPass;
+    local_device = device;
+    local_renderPass = renderPass;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_453;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_453, 1);
+        countingStream->write((uint64_t*)&cgen_var_453, 1 * 8);
+        uint64_t cgen_var_454;
+        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_454, 1);
+        countingStream->write((uint64_t*)&cgen_var_454, 1 * 8);
+        marshal_VkExtent2D(countingStream, (VkExtent2D*)(pGranularity));
+    }
+    uint32_t packetSize_vkGetRenderAreaGranularity = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetRenderAreaGranularity = OP_vkGetRenderAreaGranularity;
+    stream->write(&opcode_vkGetRenderAreaGranularity, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetRenderAreaGranularity, sizeof(uint32_t));
+    uint64_t cgen_var_455;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_455, 1);
+    stream->write((uint64_t*)&cgen_var_455, 1 * 8);
+    uint64_t cgen_var_456;
+    stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_456, 1);
+    stream->write((uint64_t*)&cgen_var_456, 1 * 8);
+    marshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
+    unmarshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
+}
+
+VkResult VkEncoder::vkCreateCommandPool(
+    VkDevice device,
+    const VkCommandPoolCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkCommandPool* pCommandPool)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkCommandPoolCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkCommandPoolCreateInfo*)pool->alloc(sizeof(const VkCommandPoolCreateInfo));
+        deepcopy_VkCommandPoolCreateInfo(pool, pCreateInfo, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_457;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_457, 1);
+        countingStream->write((uint64_t*)&cgen_var_457, 1 * 8);
+        marshal_VkCommandPoolCreateInfo(countingStream, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_458 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_458);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_459;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_459, 1);
+        countingStream->write((uint64_t*)&cgen_var_459, 8);
+    }
+    uint32_t packetSize_vkCreateCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateCommandPool = OP_vkCreateCommandPool;
+    stream->write(&opcode_vkCreateCommandPool, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateCommandPool, sizeof(uint32_t));
+    uint64_t cgen_var_460;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_460, 1);
+    stream->write((uint64_t*)&cgen_var_460, 1 * 8);
+    marshal_VkCommandPoolCreateInfo(stream, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_461 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_461);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_462;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_462, 1);
+    stream->write((uint64_t*)&cgen_var_462, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_463;
+    stream->read((uint64_t*)&cgen_var_463, 8);
+    stream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_463, (VkCommandPool*)pCommandPool, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateCommandPool_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateCommandPool_VkResult_return;
+}
+
+void VkEncoder::vkDestroyCommandPool(
+    VkDevice device,
+    VkCommandPool commandPool,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkCommandPool local_commandPool;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_commandPool = commandPool;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_464;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_464, 1);
+        countingStream->write((uint64_t*)&cgen_var_464, 1 * 8);
+        uint64_t cgen_var_465;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_465, 1);
+        countingStream->write((uint64_t*)&cgen_var_465, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_466 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_466);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyCommandPool = OP_vkDestroyCommandPool;
+    stream->write(&opcode_vkDestroyCommandPool, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyCommandPool, sizeof(uint32_t));
+    uint64_t cgen_var_467;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_467, 1);
+    stream->write((uint64_t*)&cgen_var_467, 1 * 8);
+    uint64_t cgen_var_468;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_468, 1);
+    stream->write((uint64_t*)&cgen_var_468, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_469 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_469);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkCommandPool((VkCommandPool*)&commandPool);
+}
+
+VkResult VkEncoder::vkResetCommandPool(
+    VkDevice device,
+    VkCommandPool commandPool,
+    VkCommandPoolResetFlags flags)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkCommandPool local_commandPool;
+    VkCommandPoolResetFlags local_flags;
+    local_device = device;
+    local_commandPool = commandPool;
+    local_flags = flags;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_470;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_470, 1);
+        countingStream->write((uint64_t*)&cgen_var_470, 1 * 8);
+        uint64_t cgen_var_471;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_471, 1);
+        countingStream->write((uint64_t*)&cgen_var_471, 1 * 8);
+        countingStream->write((VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags));
+    }
+    uint32_t packetSize_vkResetCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkResetCommandPool = OP_vkResetCommandPool;
+    stream->write(&opcode_vkResetCommandPool, sizeof(uint32_t));
+    stream->write(&packetSize_vkResetCommandPool, sizeof(uint32_t));
+    uint64_t cgen_var_472;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_472, 1);
+    stream->write((uint64_t*)&cgen_var_472, 1 * 8);
+    uint64_t cgen_var_473;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_473, 1);
+    stream->write((uint64_t*)&cgen_var_473, 1 * 8);
+    stream->write((VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags));
+    VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
+    stream->read(&vkResetCommandPool_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkResetCommandPool_VkResult_return;
+}
+
+VkResult VkEncoder::vkAllocateCommandBuffers(
+    VkDevice device,
+    const VkCommandBufferAllocateInfo* pAllocateInfo,
+    VkCommandBuffer* pCommandBuffers)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkCommandBufferAllocateInfo* local_pAllocateInfo;
+    local_device = device;
+    local_pAllocateInfo = nullptr;
+    if (pAllocateInfo)
+    {
+        local_pAllocateInfo = (VkCommandBufferAllocateInfo*)pool->alloc(sizeof(const VkCommandBufferAllocateInfo));
+        deepcopy_VkCommandBufferAllocateInfo(pool, pAllocateInfo, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_474;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_474, 1);
+        countingStream->write((uint64_t*)&cgen_var_474, 1 * 8);
+        marshal_VkCommandBufferAllocateInfo(countingStream, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
+        if (pAllocateInfo->commandBufferCount)
+        {
+            uint64_t* cgen_var_475;
+            countingStream->alloc((void**)&cgen_var_475, pAllocateInfo->commandBufferCount * 8);
+            countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_475, pAllocateInfo->commandBufferCount);
+            countingStream->write((uint64_t*)cgen_var_475, pAllocateInfo->commandBufferCount * 8);
+        }
+    }
+    uint32_t packetSize_vkAllocateCommandBuffers = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkAllocateCommandBuffers = OP_vkAllocateCommandBuffers;
+    stream->write(&opcode_vkAllocateCommandBuffers, sizeof(uint32_t));
+    stream->write(&packetSize_vkAllocateCommandBuffers, sizeof(uint32_t));
+    uint64_t cgen_var_476;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_476, 1);
+    stream->write((uint64_t*)&cgen_var_476, 1 * 8);
+    marshal_VkCommandBufferAllocateInfo(stream, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    if (pAllocateInfo->commandBufferCount)
+    {
+        uint64_t* cgen_var_477;
+        stream->alloc((void**)&cgen_var_477, pAllocateInfo->commandBufferCount * 8);
+        stream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_477, pAllocateInfo->commandBufferCount);
+        stream->write((uint64_t*)cgen_var_477, pAllocateInfo->commandBufferCount * 8);
+    }
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    if (pAllocateInfo->commandBufferCount)
+    {
+        uint64_t* cgen_var_478;
+        stream->alloc((void**)&cgen_var_478, pAllocateInfo->commandBufferCount * 8);
+        stream->read((uint64_t*)cgen_var_478, pAllocateInfo->commandBufferCount * 8);
+        stream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_478, (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount);
+    }
+    stream->unsetHandleMapping();
+    VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
+    stream->read(&vkAllocateCommandBuffers_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkAllocateCommandBuffers_VkResult_return;
+}
+
+void VkEncoder::vkFreeCommandBuffers(
+    VkDevice device,
+    VkCommandPool commandPool,
+    uint32_t commandBufferCount,
+    const VkCommandBuffer* pCommandBuffers)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkCommandPool local_commandPool;
+    uint32_t local_commandBufferCount;
+    VkCommandBuffer* local_pCommandBuffers;
+    local_device = device;
+    local_commandPool = commandPool;
+    local_commandBufferCount = commandBufferCount;
+    local_pCommandBuffers = nullptr;
+    if (pCommandBuffers)
+    {
+        local_pCommandBuffers = (VkCommandBuffer*)pool->dupArray(pCommandBuffers, ((commandBufferCount)) * sizeof(const VkCommandBuffer));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_479;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_479, 1);
+        countingStream->write((uint64_t*)&cgen_var_479, 1 * 8);
+        uint64_t cgen_var_480;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_480, 1);
+        countingStream->write((uint64_t*)&cgen_var_480, 1 * 8);
+        countingStream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_481 = (uint64_t)(uintptr_t)local_pCommandBuffers;
+        countingStream->putBe64(cgen_var_481);
+        if (local_pCommandBuffers)
+        {
+            if (((commandBufferCount)))
+            {
+                uint64_t* cgen_var_482;
+                countingStream->alloc((void**)&cgen_var_482, ((commandBufferCount)) * 8);
+                countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_482, ((commandBufferCount)));
+                countingStream->write((uint64_t*)cgen_var_482, ((commandBufferCount)) * 8);
+            }
+        }
+    }
+    uint32_t packetSize_vkFreeCommandBuffers = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkFreeCommandBuffers = OP_vkFreeCommandBuffers;
+    stream->write(&opcode_vkFreeCommandBuffers, sizeof(uint32_t));
+    stream->write(&packetSize_vkFreeCommandBuffers, sizeof(uint32_t));
+    uint64_t cgen_var_483;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_483, 1);
+    stream->write((uint64_t*)&cgen_var_483, 1 * 8);
+    uint64_t cgen_var_484;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_484, 1);
+    stream->write((uint64_t*)&cgen_var_484, 1 * 8);
+    stream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_485 = (uint64_t)(uintptr_t)local_pCommandBuffers;
+    stream->putBe64(cgen_var_485);
+    if (local_pCommandBuffers)
+    {
+        if (((commandBufferCount)))
+        {
+            uint64_t* cgen_var_486;
+            stream->alloc((void**)&cgen_var_486, ((commandBufferCount)) * 8);
+            stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_486, ((commandBufferCount)));
+            stream->write((uint64_t*)cgen_var_486, ((commandBufferCount)) * 8);
+        }
+    }
+    if (pCommandBuffers)
+    {
+        resources->destroyMapping()->mapHandles_VkCommandBuffer((VkCommandBuffer*)pCommandBuffers, ((commandBufferCount)));
+    }
+}
+
+VkResult VkEncoder::vkBeginCommandBuffer(
+    VkCommandBuffer commandBuffer,
+    const VkCommandBufferBeginInfo* pBeginInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkCommandBufferBeginInfo* local_pBeginInfo;
+    local_commandBuffer = commandBuffer;
+    local_pBeginInfo = nullptr;
+    if (pBeginInfo)
+    {
+        local_pBeginInfo = (VkCommandBufferBeginInfo*)pool->alloc(sizeof(const VkCommandBufferBeginInfo));
+        deepcopy_VkCommandBufferBeginInfo(pool, pBeginInfo, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_487;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_487, 1);
+        countingStream->write((uint64_t*)&cgen_var_487, 1 * 8);
+        marshal_VkCommandBufferBeginInfo(countingStream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+    }
+    uint32_t packetSize_vkBeginCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkBeginCommandBuffer = OP_vkBeginCommandBuffer;
+    stream->write(&opcode_vkBeginCommandBuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkBeginCommandBuffer, sizeof(uint32_t));
+    uint64_t cgen_var_488;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_488, 1);
+    stream->write((uint64_t*)&cgen_var_488, 1 * 8);
+    marshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+    VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
+    stream->read(&vkBeginCommandBuffer_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkBeginCommandBuffer_VkResult_return;
+}
+
+VkResult VkEncoder::vkEndCommandBuffer(
+    VkCommandBuffer commandBuffer)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    local_commandBuffer = commandBuffer;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_489;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_489, 1);
+        countingStream->write((uint64_t*)&cgen_var_489, 1 * 8);
+    }
+    uint32_t packetSize_vkEndCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkEndCommandBuffer = OP_vkEndCommandBuffer;
+    stream->write(&opcode_vkEndCommandBuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkEndCommandBuffer, sizeof(uint32_t));
+    uint64_t cgen_var_490;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_490, 1);
+    stream->write((uint64_t*)&cgen_var_490, 1 * 8);
+    VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
+    stream->read(&vkEndCommandBuffer_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkEndCommandBuffer_VkResult_return;
+}
+
+VkResult VkEncoder::vkResetCommandBuffer(
+    VkCommandBuffer commandBuffer,
+    VkCommandBufferResetFlags flags)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkCommandBufferResetFlags local_flags;
+    local_commandBuffer = commandBuffer;
+    local_flags = flags;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_491;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_491, 1);
+        countingStream->write((uint64_t*)&cgen_var_491, 1 * 8);
+        countingStream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
+    }
+    uint32_t packetSize_vkResetCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkResetCommandBuffer = OP_vkResetCommandBuffer;
+    stream->write(&opcode_vkResetCommandBuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkResetCommandBuffer, sizeof(uint32_t));
+    uint64_t cgen_var_492;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_492, 1);
+    stream->write((uint64_t*)&cgen_var_492, 1 * 8);
+    stream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
+    VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
+    stream->read(&vkResetCommandBuffer_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkResetCommandBuffer_VkResult_return;
+}
+
+void VkEncoder::vkCmdBindPipeline(
+    VkCommandBuffer commandBuffer,
+    VkPipelineBindPoint pipelineBindPoint,
+    VkPipeline pipeline)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkPipelineBindPoint local_pipelineBindPoint;
+    VkPipeline local_pipeline;
+    local_commandBuffer = commandBuffer;
+    local_pipelineBindPoint = pipelineBindPoint;
+    local_pipeline = pipeline;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_493;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_493, 1);
+        countingStream->write((uint64_t*)&cgen_var_493, 1 * 8);
+        countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+        uint64_t cgen_var_494;
+        countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_494, 1);
+        countingStream->write((uint64_t*)&cgen_var_494, 1 * 8);
+    }
+    uint32_t packetSize_vkCmdBindPipeline = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdBindPipeline = OP_vkCmdBindPipeline;
+    stream->write(&opcode_vkCmdBindPipeline, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdBindPipeline, sizeof(uint32_t));
+    uint64_t cgen_var_495;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_495, 1);
+    stream->write((uint64_t*)&cgen_var_495, 1 * 8);
+    stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    uint64_t cgen_var_496;
+    stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_496, 1);
+    stream->write((uint64_t*)&cgen_var_496, 1 * 8);
+}
+
+void VkEncoder::vkCmdSetViewport(
+    VkCommandBuffer commandBuffer,
+    uint32_t firstViewport,
+    uint32_t viewportCount,
+    const VkViewport* pViewports)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_firstViewport;
+    uint32_t local_viewportCount;
+    VkViewport* local_pViewports;
+    local_commandBuffer = commandBuffer;
+    local_firstViewport = firstViewport;
+    local_viewportCount = viewportCount;
+    local_pViewports = nullptr;
+    if (pViewports)
+    {
+        local_pViewports = (VkViewport*)pool->alloc(((viewportCount)) * sizeof(const VkViewport));
+        for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+        {
+            deepcopy_VkViewport(pool, pViewports + i, (VkViewport*)(local_pViewports + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_497;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_497, 1);
+        countingStream->write((uint64_t*)&cgen_var_497, 1 * 8);
+        countingStream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+        {
+            marshal_VkViewport(countingStream, (VkViewport*)(local_pViewports + i));
+        }
+    }
+    uint32_t packetSize_vkCmdSetViewport = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetViewport = OP_vkCmdSetViewport;
+    stream->write(&opcode_vkCmdSetViewport, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetViewport, sizeof(uint32_t));
+    uint64_t cgen_var_498;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_498, 1);
+    stream->write((uint64_t*)&cgen_var_498, 1 * 8);
+    stream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+    {
+        marshal_VkViewport(stream, (VkViewport*)(local_pViewports + i));
+    }
+}
+
+void VkEncoder::vkCmdSetScissor(
+    VkCommandBuffer commandBuffer,
+    uint32_t firstScissor,
+    uint32_t scissorCount,
+    const VkRect2D* pScissors)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_firstScissor;
+    uint32_t local_scissorCount;
+    VkRect2D* local_pScissors;
+    local_commandBuffer = commandBuffer;
+    local_firstScissor = firstScissor;
+    local_scissorCount = scissorCount;
+    local_pScissors = nullptr;
+    if (pScissors)
+    {
+        local_pScissors = (VkRect2D*)pool->alloc(((scissorCount)) * sizeof(const VkRect2D));
+        for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
+        {
+            deepcopy_VkRect2D(pool, pScissors + i, (VkRect2D*)(local_pScissors + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_499;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_499, 1);
+        countingStream->write((uint64_t*)&cgen_var_499, 1 * 8);
+        countingStream->write((uint32_t*)&local_firstScissor, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_scissorCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
+        {
+            marshal_VkRect2D(countingStream, (VkRect2D*)(local_pScissors + i));
+        }
+    }
+    uint32_t packetSize_vkCmdSetScissor = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetScissor = OP_vkCmdSetScissor;
+    stream->write(&opcode_vkCmdSetScissor, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetScissor, sizeof(uint32_t));
+    uint64_t cgen_var_500;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_500, 1);
+    stream->write((uint64_t*)&cgen_var_500, 1 * 8);
+    stream->write((uint32_t*)&local_firstScissor, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_scissorCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
+    {
+        marshal_VkRect2D(stream, (VkRect2D*)(local_pScissors + i));
+    }
+}
+
+void VkEncoder::vkCmdSetLineWidth(
+    VkCommandBuffer commandBuffer,
+    float lineWidth)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    float local_lineWidth;
+    local_commandBuffer = commandBuffer;
+    local_lineWidth = lineWidth;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_501;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_501, 1);
+        countingStream->write((uint64_t*)&cgen_var_501, 1 * 8);
+        countingStream->write((float*)&local_lineWidth, sizeof(float));
+    }
+    uint32_t packetSize_vkCmdSetLineWidth = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetLineWidth = OP_vkCmdSetLineWidth;
+    stream->write(&opcode_vkCmdSetLineWidth, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetLineWidth, sizeof(uint32_t));
+    uint64_t cgen_var_502;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_502, 1);
+    stream->write((uint64_t*)&cgen_var_502, 1 * 8);
+    stream->write((float*)&local_lineWidth, sizeof(float));
+}
+
+void VkEncoder::vkCmdSetDepthBias(
+    VkCommandBuffer commandBuffer,
+    float depthBiasConstantFactor,
+    float depthBiasClamp,
+    float depthBiasSlopeFactor)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    float local_depthBiasConstantFactor;
+    float local_depthBiasClamp;
+    float local_depthBiasSlopeFactor;
+    local_commandBuffer = commandBuffer;
+    local_depthBiasConstantFactor = depthBiasConstantFactor;
+    local_depthBiasClamp = depthBiasClamp;
+    local_depthBiasSlopeFactor = depthBiasSlopeFactor;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_503;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_503, 1);
+        countingStream->write((uint64_t*)&cgen_var_503, 1 * 8);
+        countingStream->write((float*)&local_depthBiasConstantFactor, sizeof(float));
+        countingStream->write((float*)&local_depthBiasClamp, sizeof(float));
+        countingStream->write((float*)&local_depthBiasSlopeFactor, sizeof(float));
+    }
+    uint32_t packetSize_vkCmdSetDepthBias = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetDepthBias = OP_vkCmdSetDepthBias;
+    stream->write(&opcode_vkCmdSetDepthBias, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetDepthBias, sizeof(uint32_t));
+    uint64_t cgen_var_504;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_504, 1);
+    stream->write((uint64_t*)&cgen_var_504, 1 * 8);
+    stream->write((float*)&local_depthBiasConstantFactor, sizeof(float));
+    stream->write((float*)&local_depthBiasClamp, sizeof(float));
+    stream->write((float*)&local_depthBiasSlopeFactor, sizeof(float));
+}
+
+void VkEncoder::vkCmdSetBlendConstants(
+    VkCommandBuffer commandBuffer,
+    const float blendConstants)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    float local_blendConstants[4];
+    local_commandBuffer = commandBuffer;
+    memcpy(&local_blendConstants, &blendConstants, 4 * sizeof(const float));
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_505;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_505, 1);
+        countingStream->write((uint64_t*)&cgen_var_505, 1 * 8);
+        countingStream->write((float*)&local_blendConstants, 4 * sizeof(float));
+    }
+    uint32_t packetSize_vkCmdSetBlendConstants = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetBlendConstants = OP_vkCmdSetBlendConstants;
+    stream->write(&opcode_vkCmdSetBlendConstants, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetBlendConstants, sizeof(uint32_t));
+    uint64_t cgen_var_506;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_506, 1);
+    stream->write((uint64_t*)&cgen_var_506, 1 * 8);
+    stream->write((float*)&local_blendConstants, 4 * sizeof(float));
+}
+
+void VkEncoder::vkCmdSetDepthBounds(
+    VkCommandBuffer commandBuffer,
+    float minDepthBounds,
+    float maxDepthBounds)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    float local_minDepthBounds;
+    float local_maxDepthBounds;
+    local_commandBuffer = commandBuffer;
+    local_minDepthBounds = minDepthBounds;
+    local_maxDepthBounds = maxDepthBounds;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_507;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_507, 1);
+        countingStream->write((uint64_t*)&cgen_var_507, 1 * 8);
+        countingStream->write((float*)&local_minDepthBounds, sizeof(float));
+        countingStream->write((float*)&local_maxDepthBounds, sizeof(float));
+    }
+    uint32_t packetSize_vkCmdSetDepthBounds = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetDepthBounds = OP_vkCmdSetDepthBounds;
+    stream->write(&opcode_vkCmdSetDepthBounds, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetDepthBounds, sizeof(uint32_t));
+    uint64_t cgen_var_508;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_508, 1);
+    stream->write((uint64_t*)&cgen_var_508, 1 * 8);
+    stream->write((float*)&local_minDepthBounds, sizeof(float));
+    stream->write((float*)&local_maxDepthBounds, sizeof(float));
+}
+
+void VkEncoder::vkCmdSetStencilCompareMask(
+    VkCommandBuffer commandBuffer,
+    VkStencilFaceFlags faceMask,
+    uint32_t compareMask)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkStencilFaceFlags local_faceMask;
+    uint32_t local_compareMask;
+    local_commandBuffer = commandBuffer;
+    local_faceMask = faceMask;
+    local_compareMask = compareMask;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_509;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_509, 1);
+        countingStream->write((uint64_t*)&cgen_var_509, 1 * 8);
+        countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+        countingStream->write((uint32_t*)&local_compareMask, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdSetStencilCompareMask = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetStencilCompareMask = OP_vkCmdSetStencilCompareMask;
+    stream->write(&opcode_vkCmdSetStencilCompareMask, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetStencilCompareMask, sizeof(uint32_t));
+    uint64_t cgen_var_510;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_510, 1);
+    stream->write((uint64_t*)&cgen_var_510, 1 * 8);
+    stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+    stream->write((uint32_t*)&local_compareMask, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdSetStencilWriteMask(
+    VkCommandBuffer commandBuffer,
+    VkStencilFaceFlags faceMask,
+    uint32_t writeMask)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkStencilFaceFlags local_faceMask;
+    uint32_t local_writeMask;
+    local_commandBuffer = commandBuffer;
+    local_faceMask = faceMask;
+    local_writeMask = writeMask;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_511;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_511, 1);
+        countingStream->write((uint64_t*)&cgen_var_511, 1 * 8);
+        countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+        countingStream->write((uint32_t*)&local_writeMask, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdSetStencilWriteMask = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetStencilWriteMask = OP_vkCmdSetStencilWriteMask;
+    stream->write(&opcode_vkCmdSetStencilWriteMask, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetStencilWriteMask, sizeof(uint32_t));
+    uint64_t cgen_var_512;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_512, 1);
+    stream->write((uint64_t*)&cgen_var_512, 1 * 8);
+    stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+    stream->write((uint32_t*)&local_writeMask, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdSetStencilReference(
+    VkCommandBuffer commandBuffer,
+    VkStencilFaceFlags faceMask,
+    uint32_t reference)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkStencilFaceFlags local_faceMask;
+    uint32_t local_reference;
+    local_commandBuffer = commandBuffer;
+    local_faceMask = faceMask;
+    local_reference = reference;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_513;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_513, 1);
+        countingStream->write((uint64_t*)&cgen_var_513, 1 * 8);
+        countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+        countingStream->write((uint32_t*)&local_reference, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdSetStencilReference = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetStencilReference = OP_vkCmdSetStencilReference;
+    stream->write(&opcode_vkCmdSetStencilReference, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetStencilReference, sizeof(uint32_t));
+    uint64_t cgen_var_514;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_514, 1);
+    stream->write((uint64_t*)&cgen_var_514, 1 * 8);
+    stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+    stream->write((uint32_t*)&local_reference, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdBindDescriptorSets(
+    VkCommandBuffer commandBuffer,
+    VkPipelineBindPoint pipelineBindPoint,
+    VkPipelineLayout layout,
+    uint32_t firstSet,
+    uint32_t descriptorSetCount,
+    const VkDescriptorSet* pDescriptorSets,
+    uint32_t dynamicOffsetCount,
+    const uint32_t* pDynamicOffsets)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkPipelineBindPoint local_pipelineBindPoint;
+    VkPipelineLayout local_layout;
+    uint32_t local_firstSet;
+    uint32_t local_descriptorSetCount;
+    VkDescriptorSet* local_pDescriptorSets;
+    uint32_t local_dynamicOffsetCount;
+    uint32_t* local_pDynamicOffsets;
+    local_commandBuffer = commandBuffer;
+    local_pipelineBindPoint = pipelineBindPoint;
+    local_layout = layout;
+    local_firstSet = firstSet;
+    local_descriptorSetCount = descriptorSetCount;
+    local_pDescriptorSets = nullptr;
+    if (pDescriptorSets)
+    {
+        local_pDescriptorSets = (VkDescriptorSet*)pool->dupArray(pDescriptorSets, ((descriptorSetCount)) * sizeof(const VkDescriptorSet));
+    }
+    local_dynamicOffsetCount = dynamicOffsetCount;
+    local_pDynamicOffsets = nullptr;
+    if (pDynamicOffsets)
+    {
+        local_pDynamicOffsets = (uint32_t*)pool->dupArray(pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(const uint32_t));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_515;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_515, 1);
+        countingStream->write((uint64_t*)&cgen_var_515, 1 * 8);
+        countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+        uint64_t cgen_var_516;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_516, 1);
+        countingStream->write((uint64_t*)&cgen_var_516, 1 * 8);
+        countingStream->write((uint32_t*)&local_firstSet, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
+        if (((descriptorSetCount)))
+        {
+            uint64_t* cgen_var_517;
+            countingStream->alloc((void**)&cgen_var_517, ((descriptorSetCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_517, ((descriptorSetCount)));
+            countingStream->write((uint64_t*)cgen_var_517, ((descriptorSetCount)) * 8);
+        }
+        countingStream->write((uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdBindDescriptorSets = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdBindDescriptorSets = OP_vkCmdBindDescriptorSets;
+    stream->write(&opcode_vkCmdBindDescriptorSets, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdBindDescriptorSets, sizeof(uint32_t));
+    uint64_t cgen_var_518;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_518, 1);
+    stream->write((uint64_t*)&cgen_var_518, 1 * 8);
+    stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    uint64_t cgen_var_519;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_519, 1);
+    stream->write((uint64_t*)&cgen_var_519, 1 * 8);
+    stream->write((uint32_t*)&local_firstSet, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
+    if (((descriptorSetCount)))
+    {
+        uint64_t* cgen_var_520;
+        stream->alloc((void**)&cgen_var_520, ((descriptorSetCount)) * 8);
+        stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_520, ((descriptorSetCount)));
+        stream->write((uint64_t*)cgen_var_520, ((descriptorSetCount)) * 8);
+    }
+    stream->write((uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t));
+    stream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdBindIndexBuffer(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    VkIndexType indexType)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_buffer;
+    VkDeviceSize local_offset;
+    VkIndexType local_indexType;
+    local_commandBuffer = commandBuffer;
+    local_buffer = buffer;
+    local_offset = offset;
+    local_indexType = indexType;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_521;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_521, 1);
+        countingStream->write((uint64_t*)&cgen_var_521, 1 * 8);
+        uint64_t cgen_var_522;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_522, 1);
+        countingStream->write((uint64_t*)&cgen_var_522, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+        countingStream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType));
+    }
+    uint32_t packetSize_vkCmdBindIndexBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdBindIndexBuffer = OP_vkCmdBindIndexBuffer;
+    stream->write(&opcode_vkCmdBindIndexBuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdBindIndexBuffer, sizeof(uint32_t));
+    uint64_t cgen_var_523;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_523, 1);
+    stream->write((uint64_t*)&cgen_var_523, 1 * 8);
+    uint64_t cgen_var_524;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_524, 1);
+    stream->write((uint64_t*)&cgen_var_524, 1 * 8);
+    stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+    stream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType));
+}
+
+void VkEncoder::vkCmdBindVertexBuffers(
+    VkCommandBuffer commandBuffer,
+    uint32_t firstBinding,
+    uint32_t bindingCount,
+    const VkBuffer* pBuffers,
+    const VkDeviceSize* pOffsets)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_firstBinding;
+    uint32_t local_bindingCount;
+    VkBuffer* local_pBuffers;
+    VkDeviceSize* local_pOffsets;
+    local_commandBuffer = commandBuffer;
+    local_firstBinding = firstBinding;
+    local_bindingCount = bindingCount;
+    local_pBuffers = nullptr;
+    if (pBuffers)
+    {
+        local_pBuffers = (VkBuffer*)pool->dupArray(pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
+    }
+    local_pOffsets = nullptr;
+    if (pOffsets)
+    {
+        local_pOffsets = (VkDeviceSize*)pool->dupArray(pOffsets, ((bindingCount)) * sizeof(const VkDeviceSize));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_525;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_525, 1);
+        countingStream->write((uint64_t*)&cgen_var_525, 1 * 8);
+        countingStream->write((uint32_t*)&local_firstBinding, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_bindingCount, sizeof(uint32_t));
+        if (((bindingCount)))
+        {
+            uint64_t* cgen_var_526;
+            countingStream->alloc((void**)&cgen_var_526, ((bindingCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_526, ((bindingCount)));
+            countingStream->write((uint64_t*)cgen_var_526, ((bindingCount)) * 8);
+        }
+        countingStream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
+    }
+    uint32_t packetSize_vkCmdBindVertexBuffers = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdBindVertexBuffers = OP_vkCmdBindVertexBuffers;
+    stream->write(&opcode_vkCmdBindVertexBuffers, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdBindVertexBuffers, sizeof(uint32_t));
+    uint64_t cgen_var_527;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_527, 1);
+    stream->write((uint64_t*)&cgen_var_527, 1 * 8);
+    stream->write((uint32_t*)&local_firstBinding, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_bindingCount, sizeof(uint32_t));
+    if (((bindingCount)))
+    {
+        uint64_t* cgen_var_528;
+        stream->alloc((void**)&cgen_var_528, ((bindingCount)) * 8);
+        stream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_528, ((bindingCount)));
+        stream->write((uint64_t*)cgen_var_528, ((bindingCount)) * 8);
+    }
+    stream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
+}
+
+void VkEncoder::vkCmdDraw(
+    VkCommandBuffer commandBuffer,
+    uint32_t vertexCount,
+    uint32_t instanceCount,
+    uint32_t firstVertex,
+    uint32_t firstInstance)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_vertexCount;
+    uint32_t local_instanceCount;
+    uint32_t local_firstVertex;
+    uint32_t local_firstInstance;
+    local_commandBuffer = commandBuffer;
+    local_vertexCount = vertexCount;
+    local_instanceCount = instanceCount;
+    local_firstVertex = firstVertex;
+    local_firstInstance = firstInstance;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_529;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_529, 1);
+        countingStream->write((uint64_t*)&cgen_var_529, 1 * 8);
+        countingStream->write((uint32_t*)&local_vertexCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_firstVertex, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDraw = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDraw = OP_vkCmdDraw;
+    stream->write(&opcode_vkCmdDraw, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDraw, sizeof(uint32_t));
+    uint64_t cgen_var_530;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_530, 1);
+    stream->write((uint64_t*)&cgen_var_530, 1 * 8);
+    stream->write((uint32_t*)&local_vertexCount, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_firstVertex, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDrawIndexed(
+    VkCommandBuffer commandBuffer,
+    uint32_t indexCount,
+    uint32_t instanceCount,
+    uint32_t firstIndex,
+    int32_t vertexOffset,
+    uint32_t firstInstance)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_indexCount;
+    uint32_t local_instanceCount;
+    uint32_t local_firstIndex;
+    int32_t local_vertexOffset;
+    uint32_t local_firstInstance;
+    local_commandBuffer = commandBuffer;
+    local_indexCount = indexCount;
+    local_instanceCount = instanceCount;
+    local_firstIndex = firstIndex;
+    local_vertexOffset = vertexOffset;
+    local_firstInstance = firstInstance;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_531;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_531, 1);
+        countingStream->write((uint64_t*)&cgen_var_531, 1 * 8);
+        countingStream->write((uint32_t*)&local_indexCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_firstIndex, sizeof(uint32_t));
+        countingStream->write((int32_t*)&local_vertexOffset, sizeof(int32_t));
+        countingStream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDrawIndexed = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDrawIndexed = OP_vkCmdDrawIndexed;
+    stream->write(&opcode_vkCmdDrawIndexed, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDrawIndexed, sizeof(uint32_t));
+    uint64_t cgen_var_532;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_532, 1);
+    stream->write((uint64_t*)&cgen_var_532, 1 * 8);
+    stream->write((uint32_t*)&local_indexCount, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_firstIndex, sizeof(uint32_t));
+    stream->write((int32_t*)&local_vertexOffset, sizeof(int32_t));
+    stream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDrawIndirect(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    uint32_t drawCount,
+    uint32_t stride)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_buffer;
+    VkDeviceSize local_offset;
+    uint32_t local_drawCount;
+    uint32_t local_stride;
+    local_commandBuffer = commandBuffer;
+    local_buffer = buffer;
+    local_offset = offset;
+    local_drawCount = drawCount;
+    local_stride = stride;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_533;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_533, 1);
+        countingStream->write((uint64_t*)&cgen_var_533, 1 * 8);
+        uint64_t cgen_var_534;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_534, 1);
+        countingStream->write((uint64_t*)&cgen_var_534, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+        countingStream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDrawIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDrawIndirect = OP_vkCmdDrawIndirect;
+    stream->write(&opcode_vkCmdDrawIndirect, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDrawIndirect, sizeof(uint32_t));
+    uint64_t cgen_var_535;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_535, 1);
+    stream->write((uint64_t*)&cgen_var_535, 1 * 8);
+    uint64_t cgen_var_536;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_536, 1);
+    stream->write((uint64_t*)&cgen_var_536, 1 * 8);
+    stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+    stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDrawIndexedIndirect(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    uint32_t drawCount,
+    uint32_t stride)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_buffer;
+    VkDeviceSize local_offset;
+    uint32_t local_drawCount;
+    uint32_t local_stride;
+    local_commandBuffer = commandBuffer;
+    local_buffer = buffer;
+    local_offset = offset;
+    local_drawCount = drawCount;
+    local_stride = stride;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_537;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_537, 1);
+        countingStream->write((uint64_t*)&cgen_var_537, 1 * 8);
+        uint64_t cgen_var_538;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_538, 1);
+        countingStream->write((uint64_t*)&cgen_var_538, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+        countingStream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDrawIndexedIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDrawIndexedIndirect = OP_vkCmdDrawIndexedIndirect;
+    stream->write(&opcode_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
+    uint64_t cgen_var_539;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_539, 1);
+    stream->write((uint64_t*)&cgen_var_539, 1 * 8);
+    uint64_t cgen_var_540;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_540, 1);
+    stream->write((uint64_t*)&cgen_var_540, 1 * 8);
+    stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+    stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDispatch(
+    VkCommandBuffer commandBuffer,
+    uint32_t groupCountX,
+    uint32_t groupCountY,
+    uint32_t groupCountZ)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_groupCountX;
+    uint32_t local_groupCountY;
+    uint32_t local_groupCountZ;
+    local_commandBuffer = commandBuffer;
+    local_groupCountX = groupCountX;
+    local_groupCountY = groupCountY;
+    local_groupCountZ = groupCountZ;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_541;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_541, 1);
+        countingStream->write((uint64_t*)&cgen_var_541, 1 * 8);
+        countingStream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDispatch = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDispatch = OP_vkCmdDispatch;
+    stream->write(&opcode_vkCmdDispatch, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDispatch, sizeof(uint32_t));
+    uint64_t cgen_var_542;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_542, 1);
+    stream->write((uint64_t*)&cgen_var_542, 1 * 8);
+    stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDispatchIndirect(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_buffer;
+    VkDeviceSize local_offset;
+    local_commandBuffer = commandBuffer;
+    local_buffer = buffer;
+    local_offset = offset;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_543;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_543, 1);
+        countingStream->write((uint64_t*)&cgen_var_543, 1 * 8);
+        uint64_t cgen_var_544;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_544, 1);
+        countingStream->write((uint64_t*)&cgen_var_544, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+    }
+    uint32_t packetSize_vkCmdDispatchIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDispatchIndirect = OP_vkCmdDispatchIndirect;
+    stream->write(&opcode_vkCmdDispatchIndirect, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDispatchIndirect, sizeof(uint32_t));
+    uint64_t cgen_var_545;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_545, 1);
+    stream->write((uint64_t*)&cgen_var_545, 1 * 8);
+    uint64_t cgen_var_546;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_546, 1);
+    stream->write((uint64_t*)&cgen_var_546, 1 * 8);
+    stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+}
+
+void VkEncoder::vkCmdCopyBuffer(
+    VkCommandBuffer commandBuffer,
+    VkBuffer srcBuffer,
+    VkBuffer dstBuffer,
+    uint32_t regionCount,
+    const VkBufferCopy* pRegions)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_srcBuffer;
+    VkBuffer local_dstBuffer;
+    uint32_t local_regionCount;
+    VkBufferCopy* local_pRegions;
+    local_commandBuffer = commandBuffer;
+    local_srcBuffer = srcBuffer;
+    local_dstBuffer = dstBuffer;
+    local_regionCount = regionCount;
+    local_pRegions = nullptr;
+    if (pRegions)
+    {
+        local_pRegions = (VkBufferCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferCopy));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            deepcopy_VkBufferCopy(pool, pRegions + i, (VkBufferCopy*)(local_pRegions + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_547;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_547, 1);
+        countingStream->write((uint64_t*)&cgen_var_547, 1 * 8);
+        uint64_t cgen_var_548;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_548, 1);
+        countingStream->write((uint64_t*)&cgen_var_548, 1 * 8);
+        uint64_t cgen_var_549;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_549, 1);
+        countingStream->write((uint64_t*)&cgen_var_549, 1 * 8);
+        countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            marshal_VkBufferCopy(countingStream, (VkBufferCopy*)(local_pRegions + i));
+        }
+    }
+    uint32_t packetSize_vkCmdCopyBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdCopyBuffer = OP_vkCmdCopyBuffer;
+    stream->write(&opcode_vkCmdCopyBuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdCopyBuffer, sizeof(uint32_t));
+    uint64_t cgen_var_550;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_550, 1);
+    stream->write((uint64_t*)&cgen_var_550, 1 * 8);
+    uint64_t cgen_var_551;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_551, 1);
+    stream->write((uint64_t*)&cgen_var_551, 1 * 8);
+    uint64_t cgen_var_552;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_552, 1);
+    stream->write((uint64_t*)&cgen_var_552, 1 * 8);
+    stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+    {
+        marshal_VkBufferCopy(stream, (VkBufferCopy*)(local_pRegions + i));
+    }
+}
+
+void VkEncoder::vkCmdCopyImage(
+    VkCommandBuffer commandBuffer,
+    VkImage srcImage,
+    VkImageLayout srcImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
+    uint32_t regionCount,
+    const VkImageCopy* pRegions)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkImage local_srcImage;
+    VkImageLayout local_srcImageLayout;
+    VkImage local_dstImage;
+    VkImageLayout local_dstImageLayout;
+    uint32_t local_regionCount;
+    VkImageCopy* local_pRegions;
+    local_commandBuffer = commandBuffer;
+    local_srcImage = srcImage;
+    local_srcImageLayout = srcImageLayout;
+    local_dstImage = dstImage;
+    local_dstImageLayout = dstImageLayout;
+    local_regionCount = regionCount;
+    local_pRegions = nullptr;
+    if (pRegions)
+    {
+        local_pRegions = (VkImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkImageCopy));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            deepcopy_VkImageCopy(pool, pRegions + i, (VkImageCopy*)(local_pRegions + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_553;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_553, 1);
+        countingStream->write((uint64_t*)&cgen_var_553, 1 * 8);
+        uint64_t cgen_var_554;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_554, 1);
+        countingStream->write((uint64_t*)&cgen_var_554, 1 * 8);
+        countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+        uint64_t cgen_var_555;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_555, 1);
+        countingStream->write((uint64_t*)&cgen_var_555, 1 * 8);
+        countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+        countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            marshal_VkImageCopy(countingStream, (VkImageCopy*)(local_pRegions + i));
+        }
+    }
+    uint32_t packetSize_vkCmdCopyImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdCopyImage = OP_vkCmdCopyImage;
+    stream->write(&opcode_vkCmdCopyImage, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdCopyImage, sizeof(uint32_t));
+    uint64_t cgen_var_556;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_556, 1);
+    stream->write((uint64_t*)&cgen_var_556, 1 * 8);
+    uint64_t cgen_var_557;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_557, 1);
+    stream->write((uint64_t*)&cgen_var_557, 1 * 8);
+    stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_558;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_558, 1);
+    stream->write((uint64_t*)&cgen_var_558, 1 * 8);
+    stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+    stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+    {
+        marshal_VkImageCopy(stream, (VkImageCopy*)(local_pRegions + i));
+    }
+}
+
+void VkEncoder::vkCmdBlitImage(
+    VkCommandBuffer commandBuffer,
+    VkImage srcImage,
+    VkImageLayout srcImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
+    uint32_t regionCount,
+    const VkImageBlit* pRegions,
+    VkFilter filter)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkImage local_srcImage;
+    VkImageLayout local_srcImageLayout;
+    VkImage local_dstImage;
+    VkImageLayout local_dstImageLayout;
+    uint32_t local_regionCount;
+    VkImageBlit* local_pRegions;
+    VkFilter local_filter;
+    local_commandBuffer = commandBuffer;
+    local_srcImage = srcImage;
+    local_srcImageLayout = srcImageLayout;
+    local_dstImage = dstImage;
+    local_dstImageLayout = dstImageLayout;
+    local_regionCount = regionCount;
+    local_pRegions = nullptr;
+    if (pRegions)
+    {
+        local_pRegions = (VkImageBlit*)pool->alloc(((regionCount)) * sizeof(const VkImageBlit));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            deepcopy_VkImageBlit(pool, pRegions + i, (VkImageBlit*)(local_pRegions + i));
+        }
+    }
+    local_filter = filter;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_559;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_559, 1);
+        countingStream->write((uint64_t*)&cgen_var_559, 1 * 8);
+        uint64_t cgen_var_560;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_560, 1);
+        countingStream->write((uint64_t*)&cgen_var_560, 1 * 8);
+        countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+        uint64_t cgen_var_561;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_561, 1);
+        countingStream->write((uint64_t*)&cgen_var_561, 1 * 8);
+        countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+        countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            marshal_VkImageBlit(countingStream, (VkImageBlit*)(local_pRegions + i));
+        }
+        countingStream->write((VkFilter*)&local_filter, sizeof(VkFilter));
+    }
+    uint32_t packetSize_vkCmdBlitImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdBlitImage = OP_vkCmdBlitImage;
+    stream->write(&opcode_vkCmdBlitImage, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdBlitImage, sizeof(uint32_t));
+    uint64_t cgen_var_562;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_562, 1);
+    stream->write((uint64_t*)&cgen_var_562, 1 * 8);
+    uint64_t cgen_var_563;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_563, 1);
+    stream->write((uint64_t*)&cgen_var_563, 1 * 8);
+    stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_564;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_564, 1);
+    stream->write((uint64_t*)&cgen_var_564, 1 * 8);
+    stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+    stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+    {
+        marshal_VkImageBlit(stream, (VkImageBlit*)(local_pRegions + i));
+    }
+    stream->write((VkFilter*)&local_filter, sizeof(VkFilter));
+}
+
+void VkEncoder::vkCmdCopyBufferToImage(
+    VkCommandBuffer commandBuffer,
+    VkBuffer srcBuffer,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
+    uint32_t regionCount,
+    const VkBufferImageCopy* pRegions)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_srcBuffer;
+    VkImage local_dstImage;
+    VkImageLayout local_dstImageLayout;
+    uint32_t local_regionCount;
+    VkBufferImageCopy* local_pRegions;
+    local_commandBuffer = commandBuffer;
+    local_srcBuffer = srcBuffer;
+    local_dstImage = dstImage;
+    local_dstImageLayout = dstImageLayout;
+    local_regionCount = regionCount;
+    local_pRegions = nullptr;
+    if (pRegions)
+    {
+        local_pRegions = (VkBufferImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferImageCopy));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            deepcopy_VkBufferImageCopy(pool, pRegions + i, (VkBufferImageCopy*)(local_pRegions + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_565;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_565, 1);
+        countingStream->write((uint64_t*)&cgen_var_565, 1 * 8);
+        uint64_t cgen_var_566;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_566, 1);
+        countingStream->write((uint64_t*)&cgen_var_566, 1 * 8);
+        uint64_t cgen_var_567;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_567, 1);
+        countingStream->write((uint64_t*)&cgen_var_567, 1 * 8);
+        countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+        countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            marshal_VkBufferImageCopy(countingStream, (VkBufferImageCopy*)(local_pRegions + i));
+        }
+    }
+    uint32_t packetSize_vkCmdCopyBufferToImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdCopyBufferToImage = OP_vkCmdCopyBufferToImage;
+    stream->write(&opcode_vkCmdCopyBufferToImage, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdCopyBufferToImage, sizeof(uint32_t));
+    uint64_t cgen_var_568;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_568, 1);
+    stream->write((uint64_t*)&cgen_var_568, 1 * 8);
+    uint64_t cgen_var_569;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_569, 1);
+    stream->write((uint64_t*)&cgen_var_569, 1 * 8);
+    uint64_t cgen_var_570;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_570, 1);
+    stream->write((uint64_t*)&cgen_var_570, 1 * 8);
+    stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+    stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+    {
+        marshal_VkBufferImageCopy(stream, (VkBufferImageCopy*)(local_pRegions + i));
+    }
+}
+
+void VkEncoder::vkCmdCopyImageToBuffer(
+    VkCommandBuffer commandBuffer,
+    VkImage srcImage,
+    VkImageLayout srcImageLayout,
+    VkBuffer dstBuffer,
+    uint32_t regionCount,
+    const VkBufferImageCopy* pRegions)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkImage local_srcImage;
+    VkImageLayout local_srcImageLayout;
+    VkBuffer local_dstBuffer;
+    uint32_t local_regionCount;
+    VkBufferImageCopy* local_pRegions;
+    local_commandBuffer = commandBuffer;
+    local_srcImage = srcImage;
+    local_srcImageLayout = srcImageLayout;
+    local_dstBuffer = dstBuffer;
+    local_regionCount = regionCount;
+    local_pRegions = nullptr;
+    if (pRegions)
+    {
+        local_pRegions = (VkBufferImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferImageCopy));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            deepcopy_VkBufferImageCopy(pool, pRegions + i, (VkBufferImageCopy*)(local_pRegions + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_571;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_571, 1);
+        countingStream->write((uint64_t*)&cgen_var_571, 1 * 8);
+        uint64_t cgen_var_572;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_572, 1);
+        countingStream->write((uint64_t*)&cgen_var_572, 1 * 8);
+        countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+        uint64_t cgen_var_573;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_573, 1);
+        countingStream->write((uint64_t*)&cgen_var_573, 1 * 8);
+        countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            marshal_VkBufferImageCopy(countingStream, (VkBufferImageCopy*)(local_pRegions + i));
+        }
+    }
+    uint32_t packetSize_vkCmdCopyImageToBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdCopyImageToBuffer = OP_vkCmdCopyImageToBuffer;
+    stream->write(&opcode_vkCmdCopyImageToBuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdCopyImageToBuffer, sizeof(uint32_t));
+    uint64_t cgen_var_574;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_574, 1);
+    stream->write((uint64_t*)&cgen_var_574, 1 * 8);
+    uint64_t cgen_var_575;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_575, 1);
+    stream->write((uint64_t*)&cgen_var_575, 1 * 8);
+    stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_576;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_576, 1);
+    stream->write((uint64_t*)&cgen_var_576, 1 * 8);
+    stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+    {
+        marshal_VkBufferImageCopy(stream, (VkBufferImageCopy*)(local_pRegions + i));
+    }
+}
+
+void VkEncoder::vkCmdUpdateBuffer(
+    VkCommandBuffer commandBuffer,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
+    VkDeviceSize dataSize,
+    const void* pData)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_dstBuffer;
+    VkDeviceSize local_dstOffset;
+    VkDeviceSize local_dataSize;
+    void* local_pData;
+    local_commandBuffer = commandBuffer;
+    local_dstBuffer = dstBuffer;
+    local_dstOffset = dstOffset;
+    local_dataSize = dataSize;
+    local_pData = nullptr;
+    if (pData)
+    {
+        local_pData = (void*)pool->dupArray(pData, ((dataSize)) * sizeof(const uint8_t));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_577;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_577, 1);
+        countingStream->write((uint64_t*)&cgen_var_577, 1 * 8);
+        uint64_t cgen_var_578;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_578, 1);
+        countingStream->write((uint64_t*)&cgen_var_578, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+        countingStream->write((VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
+        countingStream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t));
+    }
+    uint32_t packetSize_vkCmdUpdateBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdUpdateBuffer = OP_vkCmdUpdateBuffer;
+    stream->write(&opcode_vkCmdUpdateBuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdUpdateBuffer, sizeof(uint32_t));
+    uint64_t cgen_var_579;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_579, 1);
+    stream->write((uint64_t*)&cgen_var_579, 1 * 8);
+    uint64_t cgen_var_580;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_580, 1);
+    stream->write((uint64_t*)&cgen_var_580, 1 * 8);
+    stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+    stream->write((VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
+    stream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t));
+}
+
+void VkEncoder::vkCmdFillBuffer(
+    VkCommandBuffer commandBuffer,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
+    VkDeviceSize size,
+    uint32_t data)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_dstBuffer;
+    VkDeviceSize local_dstOffset;
+    VkDeviceSize local_size;
+    uint32_t local_data;
+    local_commandBuffer = commandBuffer;
+    local_dstBuffer = dstBuffer;
+    local_dstOffset = dstOffset;
+    local_size = size;
+    local_data = data;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_581;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_581, 1);
+        countingStream->write((uint64_t*)&cgen_var_581, 1 * 8);
+        uint64_t cgen_var_582;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_582, 1);
+        countingStream->write((uint64_t*)&cgen_var_582, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+        countingStream->write((VkDeviceSize*)&local_size, sizeof(VkDeviceSize));
+        countingStream->write((uint32_t*)&local_data, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdFillBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdFillBuffer = OP_vkCmdFillBuffer;
+    stream->write(&opcode_vkCmdFillBuffer, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdFillBuffer, sizeof(uint32_t));
+    uint64_t cgen_var_583;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_583, 1);
+    stream->write((uint64_t*)&cgen_var_583, 1 * 8);
+    uint64_t cgen_var_584;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_584, 1);
+    stream->write((uint64_t*)&cgen_var_584, 1 * 8);
+    stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+    stream->write((VkDeviceSize*)&local_size, sizeof(VkDeviceSize));
+    stream->write((uint32_t*)&local_data, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdClearColorImage(
+    VkCommandBuffer commandBuffer,
+    VkImage image,
+    VkImageLayout imageLayout,
+    const VkClearColorValue* pColor,
+    uint32_t rangeCount,
+    const VkImageSubresourceRange* pRanges)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkImage local_image;
+    VkImageLayout local_imageLayout;
+    VkClearColorValue* local_pColor;
+    uint32_t local_rangeCount;
+    VkImageSubresourceRange* local_pRanges;
+    local_commandBuffer = commandBuffer;
+    local_image = image;
+    local_imageLayout = imageLayout;
+    local_pColor = nullptr;
+    if (pColor)
+    {
+        local_pColor = (VkClearColorValue*)pool->alloc(sizeof(const VkClearColorValue));
+        deepcopy_VkClearColorValue(pool, pColor, (VkClearColorValue*)(local_pColor));
+    }
+    local_rangeCount = rangeCount;
+    local_pRanges = nullptr;
+    if (pRanges)
+    {
+        local_pRanges = (VkImageSubresourceRange*)pool->alloc(((rangeCount)) * sizeof(const VkImageSubresourceRange));
+        for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+        {
+            deepcopy_VkImageSubresourceRange(pool, pRanges + i, (VkImageSubresourceRange*)(local_pRanges + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_585;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_585, 1);
+        countingStream->write((uint64_t*)&cgen_var_585, 1 * 8);
+        uint64_t cgen_var_586;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_586, 1);
+        countingStream->write((uint64_t*)&cgen_var_586, 1 * 8);
+        countingStream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
+        marshal_VkClearColorValue(countingStream, (VkClearColorValue*)(local_pColor));
+        countingStream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+        {
+            marshal_VkImageSubresourceRange(countingStream, (VkImageSubresourceRange*)(local_pRanges + i));
+        }
+    }
+    uint32_t packetSize_vkCmdClearColorImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdClearColorImage = OP_vkCmdClearColorImage;
+    stream->write(&opcode_vkCmdClearColorImage, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdClearColorImage, sizeof(uint32_t));
+    uint64_t cgen_var_587;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_587, 1);
+    stream->write((uint64_t*)&cgen_var_587, 1 * 8);
+    uint64_t cgen_var_588;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_588, 1);
+    stream->write((uint64_t*)&cgen_var_588, 1 * 8);
+    stream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
+    marshal_VkClearColorValue(stream, (VkClearColorValue*)(local_pColor));
+    stream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+    {
+        marshal_VkImageSubresourceRange(stream, (VkImageSubresourceRange*)(local_pRanges + i));
+    }
+}
+
+void VkEncoder::vkCmdClearDepthStencilImage(
+    VkCommandBuffer commandBuffer,
+    VkImage image,
+    VkImageLayout imageLayout,
+    const VkClearDepthStencilValue* pDepthStencil,
+    uint32_t rangeCount,
+    const VkImageSubresourceRange* pRanges)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkImage local_image;
+    VkImageLayout local_imageLayout;
+    VkClearDepthStencilValue* local_pDepthStencil;
+    uint32_t local_rangeCount;
+    VkImageSubresourceRange* local_pRanges;
+    local_commandBuffer = commandBuffer;
+    local_image = image;
+    local_imageLayout = imageLayout;
+    local_pDepthStencil = nullptr;
+    if (pDepthStencil)
+    {
+        local_pDepthStencil = (VkClearDepthStencilValue*)pool->alloc(sizeof(const VkClearDepthStencilValue));
+        deepcopy_VkClearDepthStencilValue(pool, pDepthStencil, (VkClearDepthStencilValue*)(local_pDepthStencil));
+    }
+    local_rangeCount = rangeCount;
+    local_pRanges = nullptr;
+    if (pRanges)
+    {
+        local_pRanges = (VkImageSubresourceRange*)pool->alloc(((rangeCount)) * sizeof(const VkImageSubresourceRange));
+        for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+        {
+            deepcopy_VkImageSubresourceRange(pool, pRanges + i, (VkImageSubresourceRange*)(local_pRanges + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_589;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_589, 1);
+        countingStream->write((uint64_t*)&cgen_var_589, 1 * 8);
+        uint64_t cgen_var_590;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_590, 1);
+        countingStream->write((uint64_t*)&cgen_var_590, 1 * 8);
+        countingStream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
+        marshal_VkClearDepthStencilValue(countingStream, (VkClearDepthStencilValue*)(local_pDepthStencil));
+        countingStream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+        {
+            marshal_VkImageSubresourceRange(countingStream, (VkImageSubresourceRange*)(local_pRanges + i));
+        }
+    }
+    uint32_t packetSize_vkCmdClearDepthStencilImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdClearDepthStencilImage = OP_vkCmdClearDepthStencilImage;
+    stream->write(&opcode_vkCmdClearDepthStencilImage, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdClearDepthStencilImage, sizeof(uint32_t));
+    uint64_t cgen_var_591;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_591, 1);
+    stream->write((uint64_t*)&cgen_var_591, 1 * 8);
+    uint64_t cgen_var_592;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_592, 1);
+    stream->write((uint64_t*)&cgen_var_592, 1 * 8);
+    stream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
+    marshal_VkClearDepthStencilValue(stream, (VkClearDepthStencilValue*)(local_pDepthStencil));
+    stream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+    {
+        marshal_VkImageSubresourceRange(stream, (VkImageSubresourceRange*)(local_pRanges + i));
+    }
+}
+
+void VkEncoder::vkCmdClearAttachments(
+    VkCommandBuffer commandBuffer,
+    uint32_t attachmentCount,
+    const VkClearAttachment* pAttachments,
+    uint32_t rectCount,
+    const VkClearRect* pRects)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_attachmentCount;
+    VkClearAttachment* local_pAttachments;
+    uint32_t local_rectCount;
+    VkClearRect* local_pRects;
+    local_commandBuffer = commandBuffer;
+    local_attachmentCount = attachmentCount;
+    local_pAttachments = nullptr;
+    if (pAttachments)
+    {
+        local_pAttachments = (VkClearAttachment*)pool->alloc(((attachmentCount)) * sizeof(const VkClearAttachment));
+        for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
+        {
+            deepcopy_VkClearAttachment(pool, pAttachments + i, (VkClearAttachment*)(local_pAttachments + i));
+        }
+    }
+    local_rectCount = rectCount;
+    local_pRects = nullptr;
+    if (pRects)
+    {
+        local_pRects = (VkClearRect*)pool->alloc(((rectCount)) * sizeof(const VkClearRect));
+        for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
+        {
+            deepcopy_VkClearRect(pool, pRects + i, (VkClearRect*)(local_pRects + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_593;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_593, 1);
+        countingStream->write((uint64_t*)&cgen_var_593, 1 * 8);
+        countingStream->write((uint32_t*)&local_attachmentCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
+        {
+            marshal_VkClearAttachment(countingStream, (VkClearAttachment*)(local_pAttachments + i));
+        }
+        countingStream->write((uint32_t*)&local_rectCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
+        {
+            marshal_VkClearRect(countingStream, (VkClearRect*)(local_pRects + i));
+        }
+    }
+    uint32_t packetSize_vkCmdClearAttachments = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdClearAttachments = OP_vkCmdClearAttachments;
+    stream->write(&opcode_vkCmdClearAttachments, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdClearAttachments, sizeof(uint32_t));
+    uint64_t cgen_var_594;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_594, 1);
+    stream->write((uint64_t*)&cgen_var_594, 1 * 8);
+    stream->write((uint32_t*)&local_attachmentCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
+    {
+        marshal_VkClearAttachment(stream, (VkClearAttachment*)(local_pAttachments + i));
+    }
+    stream->write((uint32_t*)&local_rectCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
+    {
+        marshal_VkClearRect(stream, (VkClearRect*)(local_pRects + i));
+    }
+}
+
+void VkEncoder::vkCmdResolveImage(
+    VkCommandBuffer commandBuffer,
+    VkImage srcImage,
+    VkImageLayout srcImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
+    uint32_t regionCount,
+    const VkImageResolve* pRegions)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkImage local_srcImage;
+    VkImageLayout local_srcImageLayout;
+    VkImage local_dstImage;
+    VkImageLayout local_dstImageLayout;
+    uint32_t local_regionCount;
+    VkImageResolve* local_pRegions;
+    local_commandBuffer = commandBuffer;
+    local_srcImage = srcImage;
+    local_srcImageLayout = srcImageLayout;
+    local_dstImage = dstImage;
+    local_dstImageLayout = dstImageLayout;
+    local_regionCount = regionCount;
+    local_pRegions = nullptr;
+    if (pRegions)
+    {
+        local_pRegions = (VkImageResolve*)pool->alloc(((regionCount)) * sizeof(const VkImageResolve));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            deepcopy_VkImageResolve(pool, pRegions + i, (VkImageResolve*)(local_pRegions + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_595;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_595, 1);
+        countingStream->write((uint64_t*)&cgen_var_595, 1 * 8);
+        uint64_t cgen_var_596;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_596, 1);
+        countingStream->write((uint64_t*)&cgen_var_596, 1 * 8);
+        countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+        uint64_t cgen_var_597;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_597, 1);
+        countingStream->write((uint64_t*)&cgen_var_597, 1 * 8);
+        countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+        countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+        {
+            marshal_VkImageResolve(countingStream, (VkImageResolve*)(local_pRegions + i));
+        }
+    }
+    uint32_t packetSize_vkCmdResolveImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdResolveImage = OP_vkCmdResolveImage;
+    stream->write(&opcode_vkCmdResolveImage, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdResolveImage, sizeof(uint32_t));
+    uint64_t cgen_var_598;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_598, 1);
+    stream->write((uint64_t*)&cgen_var_598, 1 * 8);
+    uint64_t cgen_var_599;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_599, 1);
+    stream->write((uint64_t*)&cgen_var_599, 1 * 8);
+    stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_600;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_600, 1);
+    stream->write((uint64_t*)&cgen_var_600, 1 * 8);
+    stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+    stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+    {
+        marshal_VkImageResolve(stream, (VkImageResolve*)(local_pRegions + i));
+    }
+}
+
+void VkEncoder::vkCmdSetEvent(
+    VkCommandBuffer commandBuffer,
+    VkEvent event,
+    VkPipelineStageFlags stageMask)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkEvent local_event;
+    VkPipelineStageFlags local_stageMask;
+    local_commandBuffer = commandBuffer;
+    local_event = event;
+    local_stageMask = stageMask;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_601;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_601, 1);
+        countingStream->write((uint64_t*)&cgen_var_601, 1 * 8);
+        uint64_t cgen_var_602;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_602, 1);
+        countingStream->write((uint64_t*)&cgen_var_602, 1 * 8);
+        countingStream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
+    }
+    uint32_t packetSize_vkCmdSetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetEvent = OP_vkCmdSetEvent;
+    stream->write(&opcode_vkCmdSetEvent, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetEvent, sizeof(uint32_t));
+    uint64_t cgen_var_603;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_603, 1);
+    stream->write((uint64_t*)&cgen_var_603, 1 * 8);
+    uint64_t cgen_var_604;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_604, 1);
+    stream->write((uint64_t*)&cgen_var_604, 1 * 8);
+    stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
+}
+
+void VkEncoder::vkCmdResetEvent(
+    VkCommandBuffer commandBuffer,
+    VkEvent event,
+    VkPipelineStageFlags stageMask)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkEvent local_event;
+    VkPipelineStageFlags local_stageMask;
+    local_commandBuffer = commandBuffer;
+    local_event = event;
+    local_stageMask = stageMask;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_605;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_605, 1);
+        countingStream->write((uint64_t*)&cgen_var_605, 1 * 8);
+        uint64_t cgen_var_606;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_606, 1);
+        countingStream->write((uint64_t*)&cgen_var_606, 1 * 8);
+        countingStream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
+    }
+    uint32_t packetSize_vkCmdResetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdResetEvent = OP_vkCmdResetEvent;
+    stream->write(&opcode_vkCmdResetEvent, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdResetEvent, sizeof(uint32_t));
+    uint64_t cgen_var_607;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_607, 1);
+    stream->write((uint64_t*)&cgen_var_607, 1 * 8);
+    uint64_t cgen_var_608;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_608, 1);
+    stream->write((uint64_t*)&cgen_var_608, 1 * 8);
+    stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
+}
+
+void VkEncoder::vkCmdWaitEvents(
+    VkCommandBuffer commandBuffer,
+    uint32_t eventCount,
+    const VkEvent* pEvents,
+    VkPipelineStageFlags srcStageMask,
+    VkPipelineStageFlags dstStageMask,
+    uint32_t memoryBarrierCount,
+    const VkMemoryBarrier* pMemoryBarriers,
+    uint32_t bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+    uint32_t imageMemoryBarrierCount,
+    const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_eventCount;
+    VkEvent* local_pEvents;
+    VkPipelineStageFlags local_srcStageMask;
+    VkPipelineStageFlags local_dstStageMask;
+    uint32_t local_memoryBarrierCount;
+    VkMemoryBarrier* local_pMemoryBarriers;
+    uint32_t local_bufferMemoryBarrierCount;
+    VkBufferMemoryBarrier* local_pBufferMemoryBarriers;
+    uint32_t local_imageMemoryBarrierCount;
+    VkImageMemoryBarrier* local_pImageMemoryBarriers;
+    local_commandBuffer = commandBuffer;
+    local_eventCount = eventCount;
+    local_pEvents = nullptr;
+    if (pEvents)
+    {
+        local_pEvents = (VkEvent*)pool->dupArray(pEvents, ((eventCount)) * sizeof(const VkEvent));
+    }
+    local_srcStageMask = srcStageMask;
+    local_dstStageMask = dstStageMask;
+    local_memoryBarrierCount = memoryBarrierCount;
+    local_pMemoryBarriers = nullptr;
+    if (pMemoryBarriers)
+    {
+        local_pMemoryBarriers = (VkMemoryBarrier*)pool->alloc(((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
+        for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+        {
+            deepcopy_VkMemoryBarrier(pool, pMemoryBarriers + i, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+        }
+    }
+    local_bufferMemoryBarrierCount = bufferMemoryBarrierCount;
+    local_pBufferMemoryBarriers = nullptr;
+    if (pBufferMemoryBarriers)
+    {
+        local_pBufferMemoryBarriers = (VkBufferMemoryBarrier*)pool->alloc(((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
+        for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+        {
+            deepcopy_VkBufferMemoryBarrier(pool, pBufferMemoryBarriers + i, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+        }
+    }
+    local_imageMemoryBarrierCount = imageMemoryBarrierCount;
+    local_pImageMemoryBarriers = nullptr;
+    if (pImageMemoryBarriers)
+    {
+        local_pImageMemoryBarriers = (VkImageMemoryBarrier*)pool->alloc(((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
+        for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+        {
+            deepcopy_VkImageMemoryBarrier(pool, pImageMemoryBarriers + i, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_609;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_609, 1);
+        countingStream->write((uint64_t*)&cgen_var_609, 1 * 8);
+        countingStream->write((uint32_t*)&local_eventCount, sizeof(uint32_t));
+        if (((eventCount)))
+        {
+            uint64_t* cgen_var_610;
+            countingStream->alloc((void**)&cgen_var_610, ((eventCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_610, ((eventCount)));
+            countingStream->write((uint64_t*)cgen_var_610, ((eventCount)) * 8);
+        }
+        countingStream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
+        countingStream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
+        countingStream->write((uint32_t*)&local_memoryBarrierCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+        {
+            marshal_VkMemoryBarrier(countingStream, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+        }
+        countingStream->write((uint32_t*)&local_bufferMemoryBarrierCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+        {
+            marshal_VkBufferMemoryBarrier(countingStream, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+        }
+        countingStream->write((uint32_t*)&local_imageMemoryBarrierCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+        {
+            marshal_VkImageMemoryBarrier(countingStream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+        }
+    }
+    uint32_t packetSize_vkCmdWaitEvents = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdWaitEvents = OP_vkCmdWaitEvents;
+    stream->write(&opcode_vkCmdWaitEvents, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdWaitEvents, sizeof(uint32_t));
+    uint64_t cgen_var_611;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_611, 1);
+    stream->write((uint64_t*)&cgen_var_611, 1 * 8);
+    stream->write((uint32_t*)&local_eventCount, sizeof(uint32_t));
+    if (((eventCount)))
+    {
+        uint64_t* cgen_var_612;
+        stream->alloc((void**)&cgen_var_612, ((eventCount)) * 8);
+        stream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_612, ((eventCount)));
+        stream->write((uint64_t*)cgen_var_612, ((eventCount)) * 8);
+    }
+    stream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
+    stream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
+    stream->write((uint32_t*)&local_memoryBarrierCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+    {
+        marshal_VkMemoryBarrier(stream, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+    }
+    stream->write((uint32_t*)&local_bufferMemoryBarrierCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+    {
+        marshal_VkBufferMemoryBarrier(stream, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+    }
+    stream->write((uint32_t*)&local_imageMemoryBarrierCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+    {
+        marshal_VkImageMemoryBarrier(stream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+    }
+}
+
+void VkEncoder::vkCmdPipelineBarrier(
+    VkCommandBuffer commandBuffer,
+    VkPipelineStageFlags srcStageMask,
+    VkPipelineStageFlags dstStageMask,
+    VkDependencyFlags dependencyFlags,
+    uint32_t memoryBarrierCount,
+    const VkMemoryBarrier* pMemoryBarriers,
+    uint32_t bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+    uint32_t imageMemoryBarrierCount,
+    const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkPipelineStageFlags local_srcStageMask;
+    VkPipelineStageFlags local_dstStageMask;
+    VkDependencyFlags local_dependencyFlags;
+    uint32_t local_memoryBarrierCount;
+    VkMemoryBarrier* local_pMemoryBarriers;
+    uint32_t local_bufferMemoryBarrierCount;
+    VkBufferMemoryBarrier* local_pBufferMemoryBarriers;
+    uint32_t local_imageMemoryBarrierCount;
+    VkImageMemoryBarrier* local_pImageMemoryBarriers;
+    local_commandBuffer = commandBuffer;
+    local_srcStageMask = srcStageMask;
+    local_dstStageMask = dstStageMask;
+    local_dependencyFlags = dependencyFlags;
+    local_memoryBarrierCount = memoryBarrierCount;
+    local_pMemoryBarriers = nullptr;
+    if (pMemoryBarriers)
+    {
+        local_pMemoryBarriers = (VkMemoryBarrier*)pool->alloc(((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
+        for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+        {
+            deepcopy_VkMemoryBarrier(pool, pMemoryBarriers + i, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+        }
+    }
+    local_bufferMemoryBarrierCount = bufferMemoryBarrierCount;
+    local_pBufferMemoryBarriers = nullptr;
+    if (pBufferMemoryBarriers)
+    {
+        local_pBufferMemoryBarriers = (VkBufferMemoryBarrier*)pool->alloc(((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
+        for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+        {
+            deepcopy_VkBufferMemoryBarrier(pool, pBufferMemoryBarriers + i, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+        }
+    }
+    local_imageMemoryBarrierCount = imageMemoryBarrierCount;
+    local_pImageMemoryBarriers = nullptr;
+    if (pImageMemoryBarriers)
+    {
+        local_pImageMemoryBarriers = (VkImageMemoryBarrier*)pool->alloc(((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
+        for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+        {
+            deepcopy_VkImageMemoryBarrier(pool, pImageMemoryBarriers + i, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_613;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_613, 1);
+        countingStream->write((uint64_t*)&cgen_var_613, 1 * 8);
+        countingStream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
+        countingStream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
+        countingStream->write((VkDependencyFlags*)&local_dependencyFlags, sizeof(VkDependencyFlags));
+        countingStream->write((uint32_t*)&local_memoryBarrierCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+        {
+            marshal_VkMemoryBarrier(countingStream, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+        }
+        countingStream->write((uint32_t*)&local_bufferMemoryBarrierCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+        {
+            marshal_VkBufferMemoryBarrier(countingStream, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+        }
+        countingStream->write((uint32_t*)&local_imageMemoryBarrierCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+        {
+            marshal_VkImageMemoryBarrier(countingStream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+        }
+    }
+    uint32_t packetSize_vkCmdPipelineBarrier = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdPipelineBarrier = OP_vkCmdPipelineBarrier;
+    stream->write(&opcode_vkCmdPipelineBarrier, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdPipelineBarrier, sizeof(uint32_t));
+    uint64_t cgen_var_614;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_614, 1);
+    stream->write((uint64_t*)&cgen_var_614, 1 * 8);
+    stream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
+    stream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
+    stream->write((VkDependencyFlags*)&local_dependencyFlags, sizeof(VkDependencyFlags));
+    stream->write((uint32_t*)&local_memoryBarrierCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+    {
+        marshal_VkMemoryBarrier(stream, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+    }
+    stream->write((uint32_t*)&local_bufferMemoryBarrierCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+    {
+        marshal_VkBufferMemoryBarrier(stream, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+    }
+    stream->write((uint32_t*)&local_imageMemoryBarrierCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+    {
+        marshal_VkImageMemoryBarrier(stream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+    }
+}
+
+void VkEncoder::vkCmdBeginQuery(
+    VkCommandBuffer commandBuffer,
+    VkQueryPool queryPool,
+    uint32_t query,
+    VkQueryControlFlags flags)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkQueryPool local_queryPool;
+    uint32_t local_query;
+    VkQueryControlFlags local_flags;
+    local_commandBuffer = commandBuffer;
+    local_queryPool = queryPool;
+    local_query = query;
+    local_flags = flags;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_615;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_615, 1);
+        countingStream->write((uint64_t*)&cgen_var_615, 1 * 8);
+        uint64_t cgen_var_616;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_616, 1);
+        countingStream->write((uint64_t*)&cgen_var_616, 1 * 8);
+        countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
+        countingStream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
+    }
+    uint32_t packetSize_vkCmdBeginQuery = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdBeginQuery = OP_vkCmdBeginQuery;
+    stream->write(&opcode_vkCmdBeginQuery, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdBeginQuery, sizeof(uint32_t));
+    uint64_t cgen_var_617;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_617, 1);
+    stream->write((uint64_t*)&cgen_var_617, 1 * 8);
+    uint64_t cgen_var_618;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_618, 1);
+    stream->write((uint64_t*)&cgen_var_618, 1 * 8);
+    stream->write((uint32_t*)&local_query, sizeof(uint32_t));
+    stream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
+}
+
+void VkEncoder::vkCmdEndQuery(
+    VkCommandBuffer commandBuffer,
+    VkQueryPool queryPool,
+    uint32_t query)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkQueryPool local_queryPool;
+    uint32_t local_query;
+    local_commandBuffer = commandBuffer;
+    local_queryPool = queryPool;
+    local_query = query;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_619;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_619, 1);
+        countingStream->write((uint64_t*)&cgen_var_619, 1 * 8);
+        uint64_t cgen_var_620;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_620, 1);
+        countingStream->write((uint64_t*)&cgen_var_620, 1 * 8);
+        countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdEndQuery = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdEndQuery = OP_vkCmdEndQuery;
+    stream->write(&opcode_vkCmdEndQuery, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdEndQuery, sizeof(uint32_t));
+    uint64_t cgen_var_621;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_621, 1);
+    stream->write((uint64_t*)&cgen_var_621, 1 * 8);
+    uint64_t cgen_var_622;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_622, 1);
+    stream->write((uint64_t*)&cgen_var_622, 1 * 8);
+    stream->write((uint32_t*)&local_query, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdResetQueryPool(
+    VkCommandBuffer commandBuffer,
+    VkQueryPool queryPool,
+    uint32_t firstQuery,
+    uint32_t queryCount)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkQueryPool local_queryPool;
+    uint32_t local_firstQuery;
+    uint32_t local_queryCount;
+    local_commandBuffer = commandBuffer;
+    local_queryPool = queryPool;
+    local_firstQuery = firstQuery;
+    local_queryCount = queryCount;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_623;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_623, 1);
+        countingStream->write((uint64_t*)&cgen_var_623, 1 * 8);
+        uint64_t cgen_var_624;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_624, 1);
+        countingStream->write((uint64_t*)&cgen_var_624, 1 * 8);
+        countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdResetQueryPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdResetQueryPool = OP_vkCmdResetQueryPool;
+    stream->write(&opcode_vkCmdResetQueryPool, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdResetQueryPool, sizeof(uint32_t));
+    uint64_t cgen_var_625;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_625, 1);
+    stream->write((uint64_t*)&cgen_var_625, 1 * 8);
+    uint64_t cgen_var_626;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_626, 1);
+    stream->write((uint64_t*)&cgen_var_626, 1 * 8);
+    stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdWriteTimestamp(
+    VkCommandBuffer commandBuffer,
+    VkPipelineStageFlagBits pipelineStage,
+    VkQueryPool queryPool,
+    uint32_t query)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkPipelineStageFlagBits local_pipelineStage;
+    VkQueryPool local_queryPool;
+    uint32_t local_query;
+    local_commandBuffer = commandBuffer;
+    local_pipelineStage = pipelineStage;
+    local_queryPool = queryPool;
+    local_query = query;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_627;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_627, 1);
+        countingStream->write((uint64_t*)&cgen_var_627, 1 * 8);
+        countingStream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
+        uint64_t cgen_var_628;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_628, 1);
+        countingStream->write((uint64_t*)&cgen_var_628, 1 * 8);
+        countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdWriteTimestamp = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdWriteTimestamp = OP_vkCmdWriteTimestamp;
+    stream->write(&opcode_vkCmdWriteTimestamp, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdWriteTimestamp, sizeof(uint32_t));
+    uint64_t cgen_var_629;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_629, 1);
+    stream->write((uint64_t*)&cgen_var_629, 1 * 8);
+    stream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
+    uint64_t cgen_var_630;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_630, 1);
+    stream->write((uint64_t*)&cgen_var_630, 1 * 8);
+    stream->write((uint32_t*)&local_query, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdCopyQueryPoolResults(
+    VkCommandBuffer commandBuffer,
+    VkQueryPool queryPool,
+    uint32_t firstQuery,
+    uint32_t queryCount,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
+    VkDeviceSize stride,
+    VkQueryResultFlags flags)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkQueryPool local_queryPool;
+    uint32_t local_firstQuery;
+    uint32_t local_queryCount;
+    VkBuffer local_dstBuffer;
+    VkDeviceSize local_dstOffset;
+    VkDeviceSize local_stride;
+    VkQueryResultFlags local_flags;
+    local_commandBuffer = commandBuffer;
+    local_queryPool = queryPool;
+    local_firstQuery = firstQuery;
+    local_queryCount = queryCount;
+    local_dstBuffer = dstBuffer;
+    local_dstOffset = dstOffset;
+    local_stride = stride;
+    local_flags = flags;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_631;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_631, 1);
+        countingStream->write((uint64_t*)&cgen_var_631, 1 * 8);
+        uint64_t cgen_var_632;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_632, 1);
+        countingStream->write((uint64_t*)&cgen_var_632, 1 * 8);
+        countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+        uint64_t cgen_var_633;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_633, 1);
+        countingStream->write((uint64_t*)&cgen_var_633, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+        countingStream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
+        countingStream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
+    }
+    uint32_t packetSize_vkCmdCopyQueryPoolResults = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdCopyQueryPoolResults = OP_vkCmdCopyQueryPoolResults;
+    stream->write(&opcode_vkCmdCopyQueryPoolResults, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdCopyQueryPoolResults, sizeof(uint32_t));
+    uint64_t cgen_var_634;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_634, 1);
+    stream->write((uint64_t*)&cgen_var_634, 1 * 8);
+    uint64_t cgen_var_635;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_635, 1);
+    stream->write((uint64_t*)&cgen_var_635, 1 * 8);
+    stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+    uint64_t cgen_var_636;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_636, 1);
+    stream->write((uint64_t*)&cgen_var_636, 1 * 8);
+    stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+    stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
+    stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
+}
+
+void VkEncoder::vkCmdPushConstants(
+    VkCommandBuffer commandBuffer,
+    VkPipelineLayout layout,
+    VkShaderStageFlags stageFlags,
+    uint32_t offset,
+    uint32_t size,
+    const void* pValues)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkPipelineLayout local_layout;
+    VkShaderStageFlags local_stageFlags;
+    uint32_t local_offset;
+    uint32_t local_size;
+    void* local_pValues;
+    local_commandBuffer = commandBuffer;
+    local_layout = layout;
+    local_stageFlags = stageFlags;
+    local_offset = offset;
+    local_size = size;
+    local_pValues = nullptr;
+    if (pValues)
+    {
+        local_pValues = (void*)pool->dupArray(pValues, ((size)) * sizeof(const uint8_t));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_637;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_637, 1);
+        countingStream->write((uint64_t*)&cgen_var_637, 1 * 8);
+        uint64_t cgen_var_638;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_638, 1);
+        countingStream->write((uint64_t*)&cgen_var_638, 1 * 8);
+        countingStream->write((VkShaderStageFlags*)&local_stageFlags, sizeof(VkShaderStageFlags));
+        countingStream->write((uint32_t*)&local_offset, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_size, sizeof(uint32_t));
+        countingStream->write((void*)local_pValues, ((size)) * sizeof(uint8_t));
+    }
+    uint32_t packetSize_vkCmdPushConstants = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdPushConstants = OP_vkCmdPushConstants;
+    stream->write(&opcode_vkCmdPushConstants, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdPushConstants, sizeof(uint32_t));
+    uint64_t cgen_var_639;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_639, 1);
+    stream->write((uint64_t*)&cgen_var_639, 1 * 8);
+    uint64_t cgen_var_640;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_640, 1);
+    stream->write((uint64_t*)&cgen_var_640, 1 * 8);
+    stream->write((VkShaderStageFlags*)&local_stageFlags, sizeof(VkShaderStageFlags));
+    stream->write((uint32_t*)&local_offset, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_size, sizeof(uint32_t));
+    stream->write((void*)local_pValues, ((size)) * sizeof(uint8_t));
+}
+
+void VkEncoder::vkCmdBeginRenderPass(
+    VkCommandBuffer commandBuffer,
+    const VkRenderPassBeginInfo* pRenderPassBegin,
+    VkSubpassContents contents)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkRenderPassBeginInfo* local_pRenderPassBegin;
+    VkSubpassContents local_contents;
+    local_commandBuffer = commandBuffer;
+    local_pRenderPassBegin = nullptr;
+    if (pRenderPassBegin)
+    {
+        local_pRenderPassBegin = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
+        deepcopy_VkRenderPassBeginInfo(pool, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+    }
+    local_contents = contents;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_641;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_641, 1);
+        countingStream->write((uint64_t*)&cgen_var_641, 1 * 8);
+        marshal_VkRenderPassBeginInfo(countingStream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+        countingStream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
+    }
+    uint32_t packetSize_vkCmdBeginRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdBeginRenderPass = OP_vkCmdBeginRenderPass;
+    stream->write(&opcode_vkCmdBeginRenderPass, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdBeginRenderPass, sizeof(uint32_t));
+    uint64_t cgen_var_642;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_642, 1);
+    stream->write((uint64_t*)&cgen_var_642, 1 * 8);
+    marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+    stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
+}
+
+void VkEncoder::vkCmdNextSubpass(
+    VkCommandBuffer commandBuffer,
+    VkSubpassContents contents)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkSubpassContents local_contents;
+    local_commandBuffer = commandBuffer;
+    local_contents = contents;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_643;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_643, 1);
+        countingStream->write((uint64_t*)&cgen_var_643, 1 * 8);
+        countingStream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
+    }
+    uint32_t packetSize_vkCmdNextSubpass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdNextSubpass = OP_vkCmdNextSubpass;
+    stream->write(&opcode_vkCmdNextSubpass, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdNextSubpass, sizeof(uint32_t));
+    uint64_t cgen_var_644;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_644, 1);
+    stream->write((uint64_t*)&cgen_var_644, 1 * 8);
+    stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
+}
+
+void VkEncoder::vkCmdEndRenderPass(
+    VkCommandBuffer commandBuffer)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    local_commandBuffer = commandBuffer;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_645;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_645, 1);
+        countingStream->write((uint64_t*)&cgen_var_645, 1 * 8);
+    }
+    uint32_t packetSize_vkCmdEndRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdEndRenderPass = OP_vkCmdEndRenderPass;
+    stream->write(&opcode_vkCmdEndRenderPass, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdEndRenderPass, sizeof(uint32_t));
+    uint64_t cgen_var_646;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_646, 1);
+    stream->write((uint64_t*)&cgen_var_646, 1 * 8);
+}
+
+void VkEncoder::vkCmdExecuteCommands(
+    VkCommandBuffer commandBuffer,
+    uint32_t commandBufferCount,
+    const VkCommandBuffer* pCommandBuffers)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_commandBufferCount;
+    VkCommandBuffer* local_pCommandBuffers;
+    local_commandBuffer = commandBuffer;
+    local_commandBufferCount = commandBufferCount;
+    local_pCommandBuffers = nullptr;
+    if (pCommandBuffers)
+    {
+        local_pCommandBuffers = (VkCommandBuffer*)pool->dupArray(pCommandBuffers, ((commandBufferCount)) * sizeof(const VkCommandBuffer));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_647;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_647, 1);
+        countingStream->write((uint64_t*)&cgen_var_647, 1 * 8);
+        countingStream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
+        if (((commandBufferCount)))
+        {
+            uint64_t* cgen_var_648;
+            countingStream->alloc((void**)&cgen_var_648, ((commandBufferCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_648, ((commandBufferCount)));
+            countingStream->write((uint64_t*)cgen_var_648, ((commandBufferCount)) * 8);
+        }
+    }
+    uint32_t packetSize_vkCmdExecuteCommands = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdExecuteCommands = OP_vkCmdExecuteCommands;
+    stream->write(&opcode_vkCmdExecuteCommands, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdExecuteCommands, sizeof(uint32_t));
+    uint64_t cgen_var_649;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_649, 1);
+    stream->write((uint64_t*)&cgen_var_649, 1 * 8);
+    stream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
+    if (((commandBufferCount)))
+    {
+        uint64_t* cgen_var_650;
+        stream->alloc((void**)&cgen_var_650, ((commandBufferCount)) * 8);
+        stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_650, ((commandBufferCount)));
+        stream->write((uint64_t*)cgen_var_650, ((commandBufferCount)) * 8);
+    }
+}
+
+#endif
+#ifdef VK_VERSION_1_1
+VkResult VkEncoder::vkEnumerateInstanceVersion(
+    uint32_t* pApiVersion)
+{
+    VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
+    vkEnumerateInstanceVersion_VkResult_return = goldfish_vkEnumerateInstanceVersion(this, vkEnumerateInstanceVersion_VkResult_return, pApiVersion);
+    return vkEnumerateInstanceVersion_VkResult_return;
+}
+
+VkResult VkEncoder::vkBindBufferMemory2(
+    VkDevice device,
+    uint32_t bindInfoCount,
+    const VkBindBufferMemoryInfo* pBindInfos)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_bindInfoCount;
+    VkBindBufferMemoryInfo* local_pBindInfos;
+    local_device = device;
+    local_bindInfoCount = bindInfoCount;
+    local_pBindInfos = nullptr;
+    if (pBindInfos)
+    {
+        local_pBindInfos = (VkBindBufferMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            deepcopy_VkBindBufferMemoryInfo(pool, pBindInfos + i, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_651;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_651, 1);
+        countingStream->write((uint64_t*)&cgen_var_651, 1 * 8);
+        countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            marshal_VkBindBufferMemoryInfo(countingStream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+        }
+    }
+    uint32_t packetSize_vkBindBufferMemory2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkBindBufferMemory2 = OP_vkBindBufferMemory2;
+    stream->write(&opcode_vkBindBufferMemory2, sizeof(uint32_t));
+    stream->write(&packetSize_vkBindBufferMemory2, sizeof(uint32_t));
+    uint64_t cgen_var_652;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_652, 1);
+    stream->write((uint64_t*)&cgen_var_652, 1 * 8);
+    stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+    {
+        marshal_VkBindBufferMemoryInfo(stream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+    }
+    VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
+    stream->read(&vkBindBufferMemory2_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkBindBufferMemory2_VkResult_return;
+}
+
+VkResult VkEncoder::vkBindImageMemory2(
+    VkDevice device,
+    uint32_t bindInfoCount,
+    const VkBindImageMemoryInfo* pBindInfos)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_bindInfoCount;
+    VkBindImageMemoryInfo* local_pBindInfos;
+    local_device = device;
+    local_bindInfoCount = bindInfoCount;
+    local_pBindInfos = nullptr;
+    if (pBindInfos)
+    {
+        local_pBindInfos = (VkBindImageMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindImageMemoryInfo));
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            deepcopy_VkBindImageMemoryInfo(pool, pBindInfos + i, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_653;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_653, 1);
+        countingStream->write((uint64_t*)&cgen_var_653, 1 * 8);
+        countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            marshal_VkBindImageMemoryInfo(countingStream, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+        }
+    }
+    uint32_t packetSize_vkBindImageMemory2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkBindImageMemory2 = OP_vkBindImageMemory2;
+    stream->write(&opcode_vkBindImageMemory2, sizeof(uint32_t));
+    stream->write(&packetSize_vkBindImageMemory2, sizeof(uint32_t));
+    uint64_t cgen_var_654;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_654, 1);
+    stream->write((uint64_t*)&cgen_var_654, 1 * 8);
+    stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+    {
+        marshal_VkBindImageMemoryInfo(stream, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+    }
+    VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
+    stream->read(&vkBindImageMemory2_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkBindImageMemory2_VkResult_return;
+}
+
+void VkEncoder::vkGetDeviceGroupPeerMemoryFeatures(
+    VkDevice device,
+    uint32_t heapIndex,
+    uint32_t localDeviceIndex,
+    uint32_t remoteDeviceIndex,
+    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_heapIndex;
+    uint32_t local_localDeviceIndex;
+    uint32_t local_remoteDeviceIndex;
+    local_device = device;
+    local_heapIndex = heapIndex;
+    local_localDeviceIndex = localDeviceIndex;
+    local_remoteDeviceIndex = remoteDeviceIndex;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_655;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_655, 1);
+        countingStream->write((uint64_t*)&cgen_var_655, 1 * 8);
+        countingStream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
+        countingStream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+    }
+    uint32_t packetSize_vkGetDeviceGroupPeerMemoryFeatures = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDeviceGroupPeerMemoryFeatures = OP_vkGetDeviceGroupPeerMemoryFeatures;
+    stream->write(&opcode_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
+    uint64_t cgen_var_656;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_656, 1);
+    stream->write((uint64_t*)&cgen_var_656, 1 * 8);
+    stream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
+    stream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+    stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+}
+
+void VkEncoder::vkCmdSetDeviceMask(
+    VkCommandBuffer commandBuffer,
+    uint32_t deviceMask)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_deviceMask;
+    local_commandBuffer = commandBuffer;
+    local_deviceMask = deviceMask;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_657;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_657, 1);
+        countingStream->write((uint64_t*)&cgen_var_657, 1 * 8);
+        countingStream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdSetDeviceMask = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetDeviceMask = OP_vkCmdSetDeviceMask;
+    stream->write(&opcode_vkCmdSetDeviceMask, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetDeviceMask, sizeof(uint32_t));
+    uint64_t cgen_var_658;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_658, 1);
+    stream->write((uint64_t*)&cgen_var_658, 1 * 8);
+    stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDispatchBase(
+    VkCommandBuffer commandBuffer,
+    uint32_t baseGroupX,
+    uint32_t baseGroupY,
+    uint32_t baseGroupZ,
+    uint32_t groupCountX,
+    uint32_t groupCountY,
+    uint32_t groupCountZ)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_baseGroupX;
+    uint32_t local_baseGroupY;
+    uint32_t local_baseGroupZ;
+    uint32_t local_groupCountX;
+    uint32_t local_groupCountY;
+    uint32_t local_groupCountZ;
+    local_commandBuffer = commandBuffer;
+    local_baseGroupX = baseGroupX;
+    local_baseGroupY = baseGroupY;
+    local_baseGroupZ = baseGroupZ;
+    local_groupCountX = groupCountX;
+    local_groupCountY = groupCountY;
+    local_groupCountZ = groupCountZ;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_659;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_659, 1);
+        countingStream->write((uint64_t*)&cgen_var_659, 1 * 8);
+        countingStream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDispatchBase = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDispatchBase = OP_vkCmdDispatchBase;
+    stream->write(&opcode_vkCmdDispatchBase, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDispatchBase, sizeof(uint32_t));
+    uint64_t cgen_var_660;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_660, 1);
+    stream->write((uint64_t*)&cgen_var_660, 1 * 8);
+    stream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+}
+
+VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups(
+    VkInstance instance,
+    uint32_t* pPhysicalDeviceGroupCount,
+    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    local_instance = instance;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_661;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_661, 1);
+        countingStream->write((uint64_t*)&cgen_var_661, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_662 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+        countingStream->putBe64(cgen_var_662);
+        if (pPhysicalDeviceGroupCount)
+        {
+            countingStream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_663 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+        countingStream->putBe64(cgen_var_663);
+        if (pPhysicalDeviceGroupProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+            {
+                marshal_VkPhysicalDeviceGroupProperties(countingStream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkEnumeratePhysicalDeviceGroups = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkEnumeratePhysicalDeviceGroups = OP_vkEnumeratePhysicalDeviceGroups;
+    stream->write(&opcode_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
+    stream->write(&packetSize_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
+    uint64_t cgen_var_664;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_664, 1);
+    stream->write((uint64_t*)&cgen_var_664, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_665 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+    stream->putBe64(cgen_var_665);
+    if (pPhysicalDeviceGroupCount)
+    {
+        stream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_666 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+    stream->putBe64(cgen_var_666);
+    if (pPhysicalDeviceGroupProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+        {
+            marshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPhysicalDeviceGroupCount;
+    check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPhysicalDeviceGroupCount)
+    {
+        if (!(check_pPhysicalDeviceGroupCount))
+        {
+            fprintf(stderr, "fatal: pPhysicalDeviceGroupCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkPhysicalDeviceGroupProperties* check_pPhysicalDeviceGroupProperties;
+    check_pPhysicalDeviceGroupProperties = (VkPhysicalDeviceGroupProperties*)(uintptr_t)stream->getBe64();
+    if (pPhysicalDeviceGroupProperties)
+    {
+        if (!(check_pPhysicalDeviceGroupProperties))
+        {
+            fprintf(stderr, "fatal: pPhysicalDeviceGroupProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+        {
+            unmarshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+        }
+    }
+    VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
+    stream->read(&vkEnumeratePhysicalDeviceGroups_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkEnumeratePhysicalDeviceGroups_VkResult_return;
+}
+
+void VkEncoder::vkGetImageMemoryRequirements2(
+    VkDevice device,
+    const VkImageMemoryRequirementsInfo2* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImageMemoryRequirementsInfo2* local_pInfo;
+    local_device = device;
+    local_pInfo = nullptr;
+    if (pInfo)
+    {
+        local_pInfo = (VkImageMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageMemoryRequirementsInfo2));
+        deepcopy_VkImageMemoryRequirementsInfo2(pool, pInfo, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_669;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_669, 1);
+        countingStream->write((uint64_t*)&cgen_var_669, 1 * 8);
+        marshal_VkImageMemoryRequirementsInfo2(countingStream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+        marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
+    }
+    uint32_t packetSize_vkGetImageMemoryRequirements2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetImageMemoryRequirements2 = OP_vkGetImageMemoryRequirements2;
+    stream->write(&opcode_vkGetImageMemoryRequirements2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetImageMemoryRequirements2, sizeof(uint32_t));
+    uint64_t cgen_var_670;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_670, 1);
+    stream->write((uint64_t*)&cgen_var_670, 1 * 8);
+    marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+    marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+    unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetBufferMemoryRequirements2(
+    VkDevice device,
+    const VkBufferMemoryRequirementsInfo2* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkBufferMemoryRequirementsInfo2* local_pInfo;
+    local_device = device;
+    local_pInfo = nullptr;
+    if (pInfo)
+    {
+        local_pInfo = (VkBufferMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkBufferMemoryRequirementsInfo2));
+        deepcopy_VkBufferMemoryRequirementsInfo2(pool, pInfo, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_671;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_671, 1);
+        countingStream->write((uint64_t*)&cgen_var_671, 1 * 8);
+        marshal_VkBufferMemoryRequirementsInfo2(countingStream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+        marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
+    }
+    uint32_t packetSize_vkGetBufferMemoryRequirements2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetBufferMemoryRequirements2 = OP_vkGetBufferMemoryRequirements2;
+    stream->write(&opcode_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
+    uint64_t cgen_var_672;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_672, 1);
+    stream->write((uint64_t*)&cgen_var_672, 1 * 8);
+    marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+    marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+    unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetImageSparseMemoryRequirements2(
+    VkDevice device,
+    const VkImageSparseMemoryRequirementsInfo2* pInfo,
+    uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImageSparseMemoryRequirementsInfo2* local_pInfo;
+    local_device = device;
+    local_pInfo = nullptr;
+    if (pInfo)
+    {
+        local_pInfo = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageSparseMemoryRequirementsInfo2));
+        deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, pInfo, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_673;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_673, 1);
+        countingStream->write((uint64_t*)&cgen_var_673, 1 * 8);
+        marshal_VkImageSparseMemoryRequirementsInfo2(countingStream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_674 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+        countingStream->putBe64(cgen_var_674);
+        if (pSparseMemoryRequirementCount)
+        {
+            countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_675 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+        countingStream->putBe64(cgen_var_675);
+        if (pSparseMemoryRequirements)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+            {
+                marshal_VkSparseImageMemoryRequirements2(countingStream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetImageSparseMemoryRequirements2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetImageSparseMemoryRequirements2 = OP_vkGetImageSparseMemoryRequirements2;
+    stream->write(&opcode_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
+    uint64_t cgen_var_676;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_676, 1);
+    stream->write((uint64_t*)&cgen_var_676, 1 * 8);
+    marshal_VkImageSparseMemoryRequirementsInfo2(stream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_677 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+    stream->putBe64(cgen_var_677);
+    if (pSparseMemoryRequirementCount)
+    {
+        stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_678 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+    stream->putBe64(cgen_var_678);
+    if (pSparseMemoryRequirements)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+        {
+            marshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pSparseMemoryRequirementCount;
+    check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pSparseMemoryRequirementCount)
+    {
+        if (!(check_pSparseMemoryRequirementCount))
+        {
+            fprintf(stderr, "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkSparseImageMemoryRequirements2* check_pSparseMemoryRequirements;
+    check_pSparseMemoryRequirements = (VkSparseImageMemoryRequirements2*)(uintptr_t)stream->getBe64();
+    if (pSparseMemoryRequirements)
+    {
+        if (!(check_pSparseMemoryRequirements))
+        {
+            fprintf(stderr, "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+        {
+            unmarshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+        }
+    }
+}
+
+void VkEncoder::vkGetPhysicalDeviceFeatures2(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceFeatures2* pFeatures)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_681;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_681, 1);
+        countingStream->write((uint64_t*)&cgen_var_681, 1 * 8);
+        marshal_VkPhysicalDeviceFeatures2(countingStream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceFeatures2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceFeatures2 = OP_vkGetPhysicalDeviceFeatures2;
+    stream->write(&opcode_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
+    uint64_t cgen_var_682;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_682, 1);
+    stream->write((uint64_t*)&cgen_var_682, 1 * 8);
+    marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+    unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+}
+
+void VkEncoder::vkGetPhysicalDeviceProperties2(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceProperties2* pProperties)
+{
+    goldfish_vkGetPhysicalDeviceProperties2(this, physicalDevice, pProperties);
+}
+
+void VkEncoder::vkGetPhysicalDeviceFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkFormatProperties2* pFormatProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkFormat local_format;
+    local_physicalDevice = physicalDevice;
+    local_format = format;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_683;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_683, 1);
+        countingStream->write((uint64_t*)&cgen_var_683, 1 * 8);
+        countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+        marshal_VkFormatProperties2(countingStream, (VkFormatProperties2*)(pFormatProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceFormatProperties2 = OP_vkGetPhysicalDeviceFormatProperties2;
+    stream->write(&opcode_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
+    uint64_t cgen_var_684;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_684, 1);
+    stream->write((uint64_t*)&cgen_var_684, 1 * 8);
+    stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+    marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
+    unmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+    VkImageFormatProperties2* pImageFormatProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceImageFormatInfo2* local_pImageFormatInfo;
+    local_physicalDevice = physicalDevice;
+    local_pImageFormatInfo = nullptr;
+    if (pImageFormatInfo)
+    {
+        local_pImageFormatInfo = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceImageFormatInfo2));
+        deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, pImageFormatInfo, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_685;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_685, 1);
+        countingStream->write((uint64_t*)&cgen_var_685, 1 * 8);
+        marshal_VkPhysicalDeviceImageFormatInfo2(countingStream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+        marshal_VkImageFormatProperties2(countingStream, (VkImageFormatProperties2*)(pImageFormatProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2 = OP_vkGetPhysicalDeviceImageFormatProperties2;
+    stream->write(&opcode_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
+    uint64_t cgen_var_686;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_686, 1);
+    stream->write((uint64_t*)&cgen_var_686, 1 * 8);
+    marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+    marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
+    unmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
+    VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceImageFormatProperties2_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
+}
+
+void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_687;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_687, 1);
+        countingStream->write((uint64_t*)&cgen_var_687, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_688 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+        countingStream->putBe64(cgen_var_688);
+        if (pQueueFamilyPropertyCount)
+        {
+            countingStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_689 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+        countingStream->putBe64(cgen_var_689);
+        if (pQueueFamilyProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+            {
+                marshal_VkQueueFamilyProperties2(countingStream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2 = OP_vkGetPhysicalDeviceQueueFamilyProperties2;
+    stream->write(&opcode_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
+    uint64_t cgen_var_690;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_690, 1);
+    stream->write((uint64_t*)&cgen_var_690, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_691 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+    stream->putBe64(cgen_var_691);
+    if (pQueueFamilyPropertyCount)
+    {
+        stream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_692 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+    stream->putBe64(cgen_var_692);
+    if (pQueueFamilyProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+        {
+            marshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pQueueFamilyPropertyCount;
+    check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pQueueFamilyPropertyCount)
+    {
+        if (!(check_pQueueFamilyPropertyCount))
+        {
+            fprintf(stderr, "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkQueueFamilyProperties2* check_pQueueFamilyProperties;
+    check_pQueueFamilyProperties = (VkQueueFamilyProperties2*)(uintptr_t)stream->getBe64();
+    if (pQueueFamilyProperties)
+    {
+        if (!(check_pQueueFamilyProperties))
+        {
+            fprintf(stderr, "fatal: pQueueFamilyProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+        {
+            unmarshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+        }
+    }
+}
+
+void VkEncoder::vkGetPhysicalDeviceMemoryProperties2(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_695;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_695, 1);
+        countingStream->write((uint64_t*)&cgen_var_695, 1 * 8);
+        marshal_VkPhysicalDeviceMemoryProperties2(countingStream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2 = OP_vkGetPhysicalDeviceMemoryProperties2;
+    stream->write(&opcode_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
+    uint64_t cgen_var_696;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_696, 1);
+    stream->write((uint64_t*)&cgen_var_696, 1 * 8);
+    marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+    unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+    uint32_t* pPropertyCount,
+    VkSparseImageFormatProperties2* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceSparseImageFormatInfo2* local_pFormatInfo;
+    local_physicalDevice = physicalDevice;
+    local_pFormatInfo = nullptr;
+    if (pFormatInfo)
+    {
+        local_pFormatInfo = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
+        deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, pFormatInfo, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_697;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_697, 1);
+        countingStream->write((uint64_t*)&cgen_var_697, 1 * 8);
+        marshal_VkPhysicalDeviceSparseImageFormatInfo2(countingStream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_698 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_698);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_699 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_699);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkSparseImageFormatProperties2(countingStream, (VkSparseImageFormatProperties2*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2 = OP_vkGetPhysicalDeviceSparseImageFormatProperties2;
+    stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t));
+    uint64_t cgen_var_700;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_700, 1);
+    stream->write((uint64_t*)&cgen_var_700, 1 * 8);
+    marshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_701 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_701);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_702 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_702);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkSparseImageFormatProperties2* check_pProperties;
+    check_pProperties = (VkSparseImageFormatProperties2*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
+        }
+    }
+}
+
+void VkEncoder::vkTrimCommandPool(
+    VkDevice device,
+    VkCommandPool commandPool,
+    VkCommandPoolTrimFlags flags)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkCommandPool local_commandPool;
+    VkCommandPoolTrimFlags local_flags;
+    local_device = device;
+    local_commandPool = commandPool;
+    local_flags = flags;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_705;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_705, 1);
+        countingStream->write((uint64_t*)&cgen_var_705, 1 * 8);
+        uint64_t cgen_var_706;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_706, 1);
+        countingStream->write((uint64_t*)&cgen_var_706, 1 * 8);
+        countingStream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
+    }
+    uint32_t packetSize_vkTrimCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkTrimCommandPool = OP_vkTrimCommandPool;
+    stream->write(&opcode_vkTrimCommandPool, sizeof(uint32_t));
+    stream->write(&packetSize_vkTrimCommandPool, sizeof(uint32_t));
+    uint64_t cgen_var_707;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_707, 1);
+    stream->write((uint64_t*)&cgen_var_707, 1 * 8);
+    uint64_t cgen_var_708;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_708, 1);
+    stream->write((uint64_t*)&cgen_var_708, 1 * 8);
+    stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
+}
+
+void VkEncoder::vkGetDeviceQueue2(
+    VkDevice device,
+    const VkDeviceQueueInfo2* pQueueInfo,
+    VkQueue* pQueue)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDeviceQueueInfo2* local_pQueueInfo;
+    local_device = device;
+    local_pQueueInfo = nullptr;
+    if (pQueueInfo)
+    {
+        local_pQueueInfo = (VkDeviceQueueInfo2*)pool->alloc(sizeof(const VkDeviceQueueInfo2));
+        deepcopy_VkDeviceQueueInfo2(pool, pQueueInfo, (VkDeviceQueueInfo2*)(local_pQueueInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_709;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_709, 1);
+        countingStream->write((uint64_t*)&cgen_var_709, 1 * 8);
+        marshal_VkDeviceQueueInfo2(countingStream, (VkDeviceQueueInfo2*)(local_pQueueInfo));
+        uint64_t cgen_var_710;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_710, 1);
+        countingStream->write((uint64_t*)&cgen_var_710, 8);
+    }
+    uint32_t packetSize_vkGetDeviceQueue2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDeviceQueue2 = OP_vkGetDeviceQueue2;
+    stream->write(&opcode_vkGetDeviceQueue2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDeviceQueue2, sizeof(uint32_t));
+    uint64_t cgen_var_711;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_711, 1);
+    stream->write((uint64_t*)&cgen_var_711, 1 * 8);
+    marshal_VkDeviceQueueInfo2(stream, (VkDeviceQueueInfo2*)(local_pQueueInfo));
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_712;
+    stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_712, 1);
+    stream->write((uint64_t*)&cgen_var_712, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_713;
+    stream->read((uint64_t*)&cgen_var_713, 8);
+    stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_713, (VkQueue*)pQueue, 1);
+}
+
+VkResult VkEncoder::vkCreateSamplerYcbcrConversion(
+    VkDevice device,
+    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSamplerYcbcrConversionCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(sizeof(const VkSamplerYcbcrConversionCreateInfo));
+        deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, pCreateInfo, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_714;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_714, 1);
+        countingStream->write((uint64_t*)&cgen_var_714, 1 * 8);
+        marshal_VkSamplerYcbcrConversionCreateInfo(countingStream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_715 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_715);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_716;
+        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_716, 1);
+        countingStream->write((uint64_t*)&cgen_var_716, 8);
+    }
+    uint32_t packetSize_vkCreateSamplerYcbcrConversion = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateSamplerYcbcrConversion = OP_vkCreateSamplerYcbcrConversion;
+    stream->write(&opcode_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
+    uint64_t cgen_var_717;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_717, 1);
+    stream->write((uint64_t*)&cgen_var_717, 1 * 8);
+    marshal_VkSamplerYcbcrConversionCreateInfo(stream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_718 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_718);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_719;
+    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_719, 1);
+    stream->write((uint64_t*)&cgen_var_719, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_720;
+    stream->read((uint64_t*)&cgen_var_720, 8);
+    stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_720, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateSamplerYcbcrConversion_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateSamplerYcbcrConversion_VkResult_return;
+}
+
+void VkEncoder::vkDestroySamplerYcbcrConversion(
+    VkDevice device,
+    VkSamplerYcbcrConversion ycbcrConversion,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSamplerYcbcrConversion local_ycbcrConversion;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_ycbcrConversion = ycbcrConversion;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_721;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_721, 1);
+        countingStream->write((uint64_t*)&cgen_var_721, 1 * 8);
+        uint64_t cgen_var_722;
+        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_722, 1);
+        countingStream->write((uint64_t*)&cgen_var_722, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_723 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_723);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroySamplerYcbcrConversion = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroySamplerYcbcrConversion = OP_vkDestroySamplerYcbcrConversion;
+    stream->write(&opcode_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
+    uint64_t cgen_var_724;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_724, 1);
+    stream->write((uint64_t*)&cgen_var_724, 1 * 8);
+    uint64_t cgen_var_725;
+    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_725, 1);
+    stream->write((uint64_t*)&cgen_var_725, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_726 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_726);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion);
+}
+
+VkResult VkEncoder::vkCreateDescriptorUpdateTemplate(
+    VkDevice device,
+    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorUpdateTemplateCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(sizeof(const VkDescriptorUpdateTemplateCreateInfo));
+        deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, pCreateInfo, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_727;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_727, 1);
+        countingStream->write((uint64_t*)&cgen_var_727, 1 * 8);
+        marshal_VkDescriptorUpdateTemplateCreateInfo(countingStream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_728 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_728);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_729;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_729, 1);
+        countingStream->write((uint64_t*)&cgen_var_729, 8);
+    }
+    uint32_t packetSize_vkCreateDescriptorUpdateTemplate = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateDescriptorUpdateTemplate = OP_vkCreateDescriptorUpdateTemplate;
+    stream->write(&opcode_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
+    uint64_t cgen_var_730;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_730, 1);
+    stream->write((uint64_t*)&cgen_var_730, 1 * 8);
+    marshal_VkDescriptorUpdateTemplateCreateInfo(stream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_731 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_731);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_732;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_732, 1);
+    stream->write((uint64_t*)&cgen_var_732, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_733;
+    stream->read((uint64_t*)&cgen_var_733, 8);
+    stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_733, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateDescriptorUpdateTemplate_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateDescriptorUpdateTemplate_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDescriptorUpdateTemplate(
+    VkDevice device,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_734;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_734, 1);
+        countingStream->write((uint64_t*)&cgen_var_734, 1 * 8);
+        uint64_t cgen_var_735;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_735, 1);
+        countingStream->write((uint64_t*)&cgen_var_735, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_736 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_736);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyDescriptorUpdateTemplate = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyDescriptorUpdateTemplate = OP_vkDestroyDescriptorUpdateTemplate;
+    stream->write(&opcode_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
+    uint64_t cgen_var_737;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_737, 1);
+    stream->write((uint64_t*)&cgen_var_737, 1 * 8);
+    uint64_t cgen_var_738;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_738, 1);
+    stream->write((uint64_t*)&cgen_var_738, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_739 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_739);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
+}
+
+void VkEncoder::vkUpdateDescriptorSetWithTemplate(
+    VkDevice device,
+    VkDescriptorSet descriptorSet,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+    const void* pData)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorSet local_descriptorSet;
+    VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+    void* local_pData;
+    local_device = device;
+    local_descriptorSet = descriptorSet;
+    local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+    local_pData = nullptr;
+    if (pData)
+    {
+        local_pData = (void*)pool->dupArray(pData, sizeof(const uint8_t));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_740;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_740, 1);
+        countingStream->write((uint64_t*)&cgen_var_740, 1 * 8);
+        uint64_t cgen_var_741;
+        countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_741, 1);
+        countingStream->write((uint64_t*)&cgen_var_741, 1 * 8);
+        uint64_t cgen_var_742;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_742, 1);
+        countingStream->write((uint64_t*)&cgen_var_742, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_743 = (uint64_t)(uintptr_t)local_pData;
+        countingStream->putBe64(cgen_var_743);
+        if (local_pData)
+        {
+            countingStream->write((void*)local_pData, sizeof(uint8_t));
+        }
+    }
+    uint32_t packetSize_vkUpdateDescriptorSetWithTemplate = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkUpdateDescriptorSetWithTemplate = OP_vkUpdateDescriptorSetWithTemplate;
+    stream->write(&opcode_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
+    stream->write(&packetSize_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
+    uint64_t cgen_var_744;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_744, 1);
+    stream->write((uint64_t*)&cgen_var_744, 1 * 8);
+    uint64_t cgen_var_745;
+    stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_745, 1);
+    stream->write((uint64_t*)&cgen_var_745, 1 * 8);
+    uint64_t cgen_var_746;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_746, 1);
+    stream->write((uint64_t*)&cgen_var_746, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_747 = (uint64_t)(uintptr_t)local_pData;
+    stream->putBe64(cgen_var_747);
+    if (local_pData)
+    {
+        stream->write((void*)local_pData, sizeof(uint8_t));
+    }
+}
+
+void VkEncoder::vkGetPhysicalDeviceExternalBufferProperties(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+    VkExternalBufferProperties* pExternalBufferProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceExternalBufferInfo* local_pExternalBufferInfo;
+    local_physicalDevice = physicalDevice;
+    local_pExternalBufferInfo = nullptr;
+    if (pExternalBufferInfo)
+    {
+        local_pExternalBufferInfo = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalBufferInfo));
+        deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, pExternalBufferInfo, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_748;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_748, 1);
+        countingStream->write((uint64_t*)&cgen_var_748, 1 * 8);
+        marshal_VkPhysicalDeviceExternalBufferInfo(countingStream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+        marshal_VkExternalBufferProperties(countingStream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceExternalBufferProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceExternalBufferProperties = OP_vkGetPhysicalDeviceExternalBufferProperties;
+    stream->write(&opcode_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
+    uint64_t cgen_var_749;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_749, 1);
+    stream->write((uint64_t*)&cgen_var_749, 1 * 8);
+    marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+    marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+    unmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceExternalFenceProperties(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+    VkExternalFenceProperties* pExternalFenceProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceExternalFenceInfo* local_pExternalFenceInfo;
+    local_physicalDevice = physicalDevice;
+    local_pExternalFenceInfo = nullptr;
+    if (pExternalFenceInfo)
+    {
+        local_pExternalFenceInfo = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalFenceInfo));
+        deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, pExternalFenceInfo, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_750;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_750, 1);
+        countingStream->write((uint64_t*)&cgen_var_750, 1 * 8);
+        marshal_VkPhysicalDeviceExternalFenceInfo(countingStream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+        marshal_VkExternalFenceProperties(countingStream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceExternalFenceProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceExternalFenceProperties = OP_vkGetPhysicalDeviceExternalFenceProperties;
+    stream->write(&opcode_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
+    uint64_t cgen_var_751;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_751, 1);
+    stream->write((uint64_t*)&cgen_var_751, 1 * 8);
+    marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+    marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+    unmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceExternalSemaphoreProperties(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceExternalSemaphoreInfo* local_pExternalSemaphoreInfo;
+    local_physicalDevice = physicalDevice;
+    local_pExternalSemaphoreInfo = nullptr;
+    if (pExternalSemaphoreInfo)
+    {
+        local_pExternalSemaphoreInfo = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
+        deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, pExternalSemaphoreInfo, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_752;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_752, 1);
+        countingStream->write((uint64_t*)&cgen_var_752, 1 * 8);
+        marshal_VkPhysicalDeviceExternalSemaphoreInfo(countingStream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+        marshal_VkExternalSemaphoreProperties(countingStream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceExternalSemaphoreProperties = OP_vkGetPhysicalDeviceExternalSemaphoreProperties;
+    stream->write(&opcode_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
+    uint64_t cgen_var_753;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_753, 1);
+    stream->write((uint64_t*)&cgen_var_753, 1 * 8);
+    marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+    marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+    unmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+}
+
+void VkEncoder::vkGetDescriptorSetLayoutSupport(
+    VkDevice device,
+    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    VkDescriptorSetLayoutSupport* pSupport)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorSetLayoutCreateInfo* local_pCreateInfo;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
+        deepcopy_VkDescriptorSetLayoutCreateInfo(pool, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_754;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_754, 1);
+        countingStream->write((uint64_t*)&cgen_var_754, 1 * 8);
+        marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+        marshal_VkDescriptorSetLayoutSupport(countingStream, (VkDescriptorSetLayoutSupport*)(pSupport));
+    }
+    uint32_t packetSize_vkGetDescriptorSetLayoutSupport = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDescriptorSetLayoutSupport = OP_vkGetDescriptorSetLayoutSupport;
+    stream->write(&opcode_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
+    uint64_t cgen_var_755;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_755, 1);
+    stream->write((uint64_t*)&cgen_var_755, 1 * 8);
+    marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+    marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
+    unmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
+}
+
+#endif
+#ifdef VK_KHR_surface
+void VkEncoder::vkDestroySurfaceKHR(
+    VkInstance instance,
+    VkSurfaceKHR surface,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkSurfaceKHR local_surface;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_surface = surface;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_756;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_756, 1);
+        countingStream->write((uint64_t*)&cgen_var_756, 1 * 8);
+        uint64_t cgen_var_757;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_757, 1);
+        countingStream->write((uint64_t*)&cgen_var_757, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_758 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_758);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroySurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroySurfaceKHR = OP_vkDestroySurfaceKHR;
+    stream->write(&opcode_vkDestroySurfaceKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroySurfaceKHR, sizeof(uint32_t));
+    uint64_t cgen_var_759;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_759, 1);
+    stream->write((uint64_t*)&cgen_var_759, 1 * 8);
+    uint64_t cgen_var_760;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_760, 1);
+    stream->write((uint64_t*)&cgen_var_760, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_761 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_761);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&surface);
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex,
+    VkSurfaceKHR surface,
+    VkBool32* pSupported)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    uint32_t local_queueFamilyIndex;
+    VkSurfaceKHR local_surface;
+    local_physicalDevice = physicalDevice;
+    local_queueFamilyIndex = queueFamilyIndex;
+    local_surface = surface;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_762;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_762, 1);
+        countingStream->write((uint64_t*)&cgen_var_762, 1 * 8);
+        countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+        uint64_t cgen_var_763;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_763, 1);
+        countingStream->write((uint64_t*)&cgen_var_763, 1 * 8);
+        countingStream->write((VkBool32*)pSupported, sizeof(VkBool32));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceSurfaceSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceSurfaceSupportKHR = OP_vkGetPhysicalDeviceSurfaceSupportKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t));
+    uint64_t cgen_var_764;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_764, 1);
+    stream->write((uint64_t*)&cgen_var_764, 1 * 8);
+    stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+    uint64_t cgen_var_765;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_765, 1);
+    stream->write((uint64_t*)&cgen_var_765, 1 * 8);
+    stream->write((VkBool32*)pSupported, sizeof(VkBool32));
+    stream->read((VkBool32*)pSupported, sizeof(VkBool32));
+    VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+    VkPhysicalDevice physicalDevice,
+    VkSurfaceKHR surface,
+    VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkSurfaceKHR local_surface;
+    local_physicalDevice = physicalDevice;
+    local_surface = surface;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_766;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_766, 1);
+        countingStream->write((uint64_t*)&cgen_var_766, 1 * 8);
+        uint64_t cgen_var_767;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_767, 1);
+        countingStream->write((uint64_t*)&cgen_var_767, 1 * 8);
+        marshal_VkSurfaceCapabilitiesKHR(countingStream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_768;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_768, 1);
+    stream->write((uint64_t*)&cgen_var_768, 1 * 8);
+    uint64_t cgen_var_769;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_769, 1);
+    stream->write((uint64_t*)&cgen_var_769, 1 * 8);
+    marshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
+    unmarshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
+    VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR(
+    VkPhysicalDevice physicalDevice,
+    VkSurfaceKHR surface,
+    uint32_t* pSurfaceFormatCount,
+    VkSurfaceFormatKHR* pSurfaceFormats)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkSurfaceKHR local_surface;
+    local_physicalDevice = physicalDevice;
+    local_surface = surface;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_770;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_770, 1);
+        countingStream->write((uint64_t*)&cgen_var_770, 1 * 8);
+        uint64_t cgen_var_771;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_771, 1);
+        countingStream->write((uint64_t*)&cgen_var_771, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_772 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+        countingStream->putBe64(cgen_var_772);
+        if (pSurfaceFormatCount)
+        {
+            countingStream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_773 = (uint64_t)(uintptr_t)pSurfaceFormats;
+        countingStream->putBe64(cgen_var_773);
+        if (pSurfaceFormats)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+            {
+                marshal_VkSurfaceFormatKHR(countingStream, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceSurfaceFormatsKHR = OP_vkGetPhysicalDeviceSurfaceFormatsKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t));
+    uint64_t cgen_var_774;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_774, 1);
+    stream->write((uint64_t*)&cgen_var_774, 1 * 8);
+    uint64_t cgen_var_775;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_775, 1);
+    stream->write((uint64_t*)&cgen_var_775, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_776 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+    stream->putBe64(cgen_var_776);
+    if (pSurfaceFormatCount)
+    {
+        stream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_777 = (uint64_t)(uintptr_t)pSurfaceFormats;
+    stream->putBe64(cgen_var_777);
+    if (pSurfaceFormats)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+        {
+            marshal_VkSurfaceFormatKHR(stream, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pSurfaceFormatCount;
+    check_pSurfaceFormatCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pSurfaceFormatCount)
+    {
+        if (!(check_pSurfaceFormatCount))
+        {
+            fprintf(stderr, "fatal: pSurfaceFormatCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkSurfaceFormatKHR* check_pSurfaceFormats;
+    check_pSurfaceFormats = (VkSurfaceFormatKHR*)(uintptr_t)stream->getBe64();
+    if (pSurfaceFormats)
+    {
+        if (!(check_pSurfaceFormats))
+        {
+            fprintf(stderr, "fatal: pSurfaceFormats inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+        {
+            unmarshal_VkSurfaceFormatKHR(stream, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
+        }
+    }
+    VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR(
+    VkPhysicalDevice physicalDevice,
+    VkSurfaceKHR surface,
+    uint32_t* pPresentModeCount,
+    VkPresentModeKHR* pPresentModes)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkSurfaceKHR local_surface;
+    local_physicalDevice = physicalDevice;
+    local_surface = surface;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_780;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_780, 1);
+        countingStream->write((uint64_t*)&cgen_var_780, 1 * 8);
+        uint64_t cgen_var_781;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_781, 1);
+        countingStream->write((uint64_t*)&cgen_var_781, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_782 = (uint64_t)(uintptr_t)pPresentModeCount;
+        countingStream->putBe64(cgen_var_782);
+        if (pPresentModeCount)
+        {
+            countingStream->write((uint32_t*)pPresentModeCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_783 = (uint64_t)(uintptr_t)pPresentModes;
+        countingStream->putBe64(cgen_var_783);
+        if (pPresentModes)
+        {
+            countingStream->write((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceSurfacePresentModesKHR = OP_vkGetPhysicalDeviceSurfacePresentModesKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_784;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_784, 1);
+    stream->write((uint64_t*)&cgen_var_784, 1 * 8);
+    uint64_t cgen_var_785;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_785, 1);
+    stream->write((uint64_t*)&cgen_var_785, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_786 = (uint64_t)(uintptr_t)pPresentModeCount;
+    stream->putBe64(cgen_var_786);
+    if (pPresentModeCount)
+    {
+        stream->write((uint32_t*)pPresentModeCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_787 = (uint64_t)(uintptr_t)pPresentModes;
+    stream->putBe64(cgen_var_787);
+    if (pPresentModes)
+    {
+        stream->write((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPresentModeCount;
+    check_pPresentModeCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPresentModeCount)
+    {
+        if (!(check_pPresentModeCount))
+        {
+            fprintf(stderr, "fatal: pPresentModeCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPresentModeCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkPresentModeKHR* check_pPresentModes;
+    check_pPresentModes = (VkPresentModeKHR*)(uintptr_t)stream->getBe64();
+    if (pPresentModes)
+    {
+        if (!(check_pPresentModes))
+        {
+            fprintf(stderr, "fatal: pPresentModes inconsistent between guest and host\n");
+        }
+        stream->read((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
+    }
+    VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_swapchain
+VkResult VkEncoder::vkCreateSwapchainKHR(
+    VkDevice device,
+    const VkSwapchainCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSwapchainKHR* pSwapchain)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSwapchainCreateInfoKHR* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkSwapchainCreateInfoKHR*)pool->alloc(sizeof(const VkSwapchainCreateInfoKHR));
+        deepcopy_VkSwapchainCreateInfoKHR(pool, pCreateInfo, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_790;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_790, 1);
+        countingStream->write((uint64_t*)&cgen_var_790, 1 * 8);
+        marshal_VkSwapchainCreateInfoKHR(countingStream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_791 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_791);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_792;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_792, 1);
+        countingStream->write((uint64_t*)&cgen_var_792, 8);
+    }
+    uint32_t packetSize_vkCreateSwapchainKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateSwapchainKHR = OP_vkCreateSwapchainKHR;
+    stream->write(&opcode_vkCreateSwapchainKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateSwapchainKHR, sizeof(uint32_t));
+    uint64_t cgen_var_793;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_793, 1);
+    stream->write((uint64_t*)&cgen_var_793, 1 * 8);
+    marshal_VkSwapchainCreateInfoKHR(stream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_794 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_794);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_795;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_795, 1);
+    stream->write((uint64_t*)&cgen_var_795, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_796;
+    stream->read((uint64_t*)&cgen_var_796, 8);
+    stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_796, (VkSwapchainKHR*)pSwapchain, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateSwapchainKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateSwapchainKHR_VkResult_return;
+}
+
+void VkEncoder::vkDestroySwapchainKHR(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSwapchainKHR local_swapchain;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_swapchain = swapchain;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_797;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_797, 1);
+        countingStream->write((uint64_t*)&cgen_var_797, 1 * 8);
+        uint64_t cgen_var_798;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_798, 1);
+        countingStream->write((uint64_t*)&cgen_var_798, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_799 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_799);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroySwapchainKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroySwapchainKHR = OP_vkDestroySwapchainKHR;
+    stream->write(&opcode_vkDestroySwapchainKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroySwapchainKHR, sizeof(uint32_t));
+    uint64_t cgen_var_800;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_800, 1);
+    stream->write((uint64_t*)&cgen_var_800, 1 * 8);
+    uint64_t cgen_var_801;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_801, 1);
+    stream->write((uint64_t*)&cgen_var_801, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_802 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_802);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&swapchain);
+}
+
+VkResult VkEncoder::vkGetSwapchainImagesKHR(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    uint32_t* pSwapchainImageCount,
+    VkImage* pSwapchainImages)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSwapchainKHR local_swapchain;
+    local_device = device;
+    local_swapchain = swapchain;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_803;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_803, 1);
+        countingStream->write((uint64_t*)&cgen_var_803, 1 * 8);
+        uint64_t cgen_var_804;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_804, 1);
+        countingStream->write((uint64_t*)&cgen_var_804, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_805 = (uint64_t)(uintptr_t)pSwapchainImageCount;
+        countingStream->putBe64(cgen_var_805);
+        if (pSwapchainImageCount)
+        {
+            countingStream->write((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_806 = (uint64_t)(uintptr_t)pSwapchainImages;
+        countingStream->putBe64(cgen_var_806);
+        if (pSwapchainImages)
+        {
+            if ((*(pSwapchainImageCount)))
+            {
+                uint64_t* cgen_var_807;
+                countingStream->alloc((void**)&cgen_var_807, (*(pSwapchainImageCount)) * 8);
+                countingStream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_807, (*(pSwapchainImageCount)));
+                countingStream->write((uint64_t*)cgen_var_807, (*(pSwapchainImageCount)) * 8);
+            }
+        }
+    }
+    uint32_t packetSize_vkGetSwapchainImagesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetSwapchainImagesKHR = OP_vkGetSwapchainImagesKHR;
+    stream->write(&opcode_vkGetSwapchainImagesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetSwapchainImagesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_808;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_808, 1);
+    stream->write((uint64_t*)&cgen_var_808, 1 * 8);
+    uint64_t cgen_var_809;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_809, 1);
+    stream->write((uint64_t*)&cgen_var_809, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_810 = (uint64_t)(uintptr_t)pSwapchainImageCount;
+    stream->putBe64(cgen_var_810);
+    if (pSwapchainImageCount)
+    {
+        stream->write((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    // WARNING PTR CHECK
+    uint64_t cgen_var_811 = (uint64_t)(uintptr_t)pSwapchainImages;
+    stream->putBe64(cgen_var_811);
+    if (pSwapchainImages)
+    {
+        if ((*(pSwapchainImageCount)))
+        {
+            uint64_t* cgen_var_812;
+            stream->alloc((void**)&cgen_var_812, (*(pSwapchainImageCount)) * 8);
+            stream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_812, (*(pSwapchainImageCount)));
+            stream->write((uint64_t*)cgen_var_812, (*(pSwapchainImageCount)) * 8);
+        }
+    }
+    stream->setHandleMapping(resources->unwrapMapping());
+    // WARNING PTR CHECK
+    uint32_t* check_pSwapchainImageCount;
+    check_pSwapchainImageCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pSwapchainImageCount)
+    {
+        if (!(check_pSwapchainImageCount))
+        {
+            fprintf(stderr, "fatal: pSwapchainImageCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkImage* check_pSwapchainImages;
+    check_pSwapchainImages = (VkImage*)(uintptr_t)stream->getBe64();
+    if (pSwapchainImages)
+    {
+        if (!(check_pSwapchainImages))
+        {
+            fprintf(stderr, "fatal: pSwapchainImages inconsistent between guest and host\n");
+        }
+        if ((*(pSwapchainImageCount)))
+        {
+            uint64_t* cgen_var_815;
+            stream->alloc((void**)&cgen_var_815, (*(pSwapchainImageCount)) * 8);
+            stream->read((uint64_t*)cgen_var_815, (*(pSwapchainImageCount)) * 8);
+            stream->handleMapping()->mapHandles_u64_VkImage(cgen_var_815, (VkImage*)pSwapchainImages, (*(pSwapchainImageCount)));
+        }
+    }
+    VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetSwapchainImagesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetSwapchainImagesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkAcquireNextImageKHR(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    uint64_t timeout,
+    VkSemaphore semaphore,
+    VkFence fence,
+    uint32_t* pImageIndex)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSwapchainKHR local_swapchain;
+    uint64_t local_timeout;
+    VkSemaphore local_semaphore;
+    VkFence local_fence;
+    local_device = device;
+    local_swapchain = swapchain;
+    local_timeout = timeout;
+    local_semaphore = semaphore;
+    local_fence = fence;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_816;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_816, 1);
+        countingStream->write((uint64_t*)&cgen_var_816, 1 * 8);
+        uint64_t cgen_var_817;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_817, 1);
+        countingStream->write((uint64_t*)&cgen_var_817, 1 * 8);
+        countingStream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
+        uint64_t cgen_var_818;
+        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_818, 1);
+        countingStream->write((uint64_t*)&cgen_var_818, 1 * 8);
+        uint64_t cgen_var_819;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_819, 1);
+        countingStream->write((uint64_t*)&cgen_var_819, 1 * 8);
+        countingStream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkAcquireNextImageKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkAcquireNextImageKHR = OP_vkAcquireNextImageKHR;
+    stream->write(&opcode_vkAcquireNextImageKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkAcquireNextImageKHR, sizeof(uint32_t));
+    uint64_t cgen_var_820;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_820, 1);
+    stream->write((uint64_t*)&cgen_var_820, 1 * 8);
+    uint64_t cgen_var_821;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_821, 1);
+    stream->write((uint64_t*)&cgen_var_821, 1 * 8);
+    stream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
+    uint64_t cgen_var_822;
+    stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_822, 1);
+    stream->write((uint64_t*)&cgen_var_822, 1 * 8);
+    uint64_t cgen_var_823;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_823, 1);
+    stream->write((uint64_t*)&cgen_var_823, 1 * 8);
+    stream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
+    stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
+    VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkAcquireNextImageKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkAcquireNextImageKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkQueuePresentKHR(
+    VkQueue queue,
+    const VkPresentInfoKHR* pPresentInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkQueue local_queue;
+    VkPresentInfoKHR* local_pPresentInfo;
+    local_queue = queue;
+    local_pPresentInfo = nullptr;
+    if (pPresentInfo)
+    {
+        local_pPresentInfo = (VkPresentInfoKHR*)pool->alloc(sizeof(const VkPresentInfoKHR));
+        deepcopy_VkPresentInfoKHR(pool, pPresentInfo, (VkPresentInfoKHR*)(local_pPresentInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_824;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_824, 1);
+        countingStream->write((uint64_t*)&cgen_var_824, 1 * 8);
+        marshal_VkPresentInfoKHR(countingStream, (VkPresentInfoKHR*)(local_pPresentInfo));
+    }
+    uint32_t packetSize_vkQueuePresentKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueuePresentKHR = OP_vkQueuePresentKHR;
+    stream->write(&opcode_vkQueuePresentKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueuePresentKHR, sizeof(uint32_t));
+    uint64_t cgen_var_825;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_825, 1);
+    stream->write((uint64_t*)&cgen_var_825, 1 * 8);
+    marshal_VkPresentInfoKHR(stream, (VkPresentInfoKHR*)(local_pPresentInfo));
+    VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkQueuePresentKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkQueuePresentKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDeviceGroupPresentCapabilitiesKHR(
+    VkDevice device,
+    VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    local_device = device;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_826;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_826, 1);
+        countingStream->write((uint64_t*)&cgen_var_826, 1 * 8);
+        marshal_VkDeviceGroupPresentCapabilitiesKHR(countingStream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
+    }
+    uint32_t packetSize_vkGetDeviceGroupPresentCapabilitiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDeviceGroupPresentCapabilitiesKHR = OP_vkGetDeviceGroupPresentCapabilitiesKHR;
+    stream->write(&opcode_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_827;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_827, 1);
+    stream->write((uint64_t*)&cgen_var_827, 1 * 8);
+    marshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
+    unmarshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
+    VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR(
+    VkDevice device,
+    VkSurfaceKHR surface,
+    VkDeviceGroupPresentModeFlagsKHR* pModes)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSurfaceKHR local_surface;
+    local_device = device;
+    local_surface = surface;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_828;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_828, 1);
+        countingStream->write((uint64_t*)&cgen_var_828, 1 * 8);
+        uint64_t cgen_var_829;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_829, 1);
+        countingStream->write((uint64_t*)&cgen_var_829, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_830 = (uint64_t)(uintptr_t)pModes;
+        countingStream->putBe64(cgen_var_830);
+        if (pModes)
+        {
+            countingStream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+        }
+    }
+    uint32_t packetSize_vkGetDeviceGroupSurfacePresentModesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDeviceGroupSurfacePresentModesKHR = OP_vkGetDeviceGroupSurfacePresentModesKHR;
+    stream->write(&opcode_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_831;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_831, 1);
+    stream->write((uint64_t*)&cgen_var_831, 1 * 8);
+    uint64_t cgen_var_832;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_832, 1);
+    stream->write((uint64_t*)&cgen_var_832, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_833 = (uint64_t)(uintptr_t)pModes;
+    stream->putBe64(cgen_var_833);
+    if (pModes)
+    {
+        stream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+    }
+    // WARNING PTR CHECK
+    VkDeviceGroupPresentModeFlagsKHR* check_pModes;
+    check_pModes = (VkDeviceGroupPresentModeFlagsKHR*)(uintptr_t)stream->getBe64();
+    if (pModes)
+    {
+        if (!(check_pModes))
+        {
+            fprintf(stderr, "fatal: pModes inconsistent between guest and host\n");
+        }
+        stream->read((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+    }
+    VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR(
+    VkPhysicalDevice physicalDevice,
+    VkSurfaceKHR surface,
+    uint32_t* pRectCount,
+    VkRect2D* pRects)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkSurfaceKHR local_surface;
+    local_physicalDevice = physicalDevice;
+    local_surface = surface;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_835;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_835, 1);
+        countingStream->write((uint64_t*)&cgen_var_835, 1 * 8);
+        uint64_t cgen_var_836;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_836, 1);
+        countingStream->write((uint64_t*)&cgen_var_836, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_837 = (uint64_t)(uintptr_t)pRectCount;
+        countingStream->putBe64(cgen_var_837);
+        if (pRectCount)
+        {
+            countingStream->write((uint32_t*)pRectCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_838 = (uint64_t)(uintptr_t)pRects;
+        countingStream->putBe64(cgen_var_838);
+        if (pRects)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
+            {
+                marshal_VkRect2D(countingStream, (VkRect2D*)(pRects + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDevicePresentRectanglesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDevicePresentRectanglesKHR = OP_vkGetPhysicalDevicePresentRectanglesKHR;
+    stream->write(&opcode_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_839;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_839, 1);
+    stream->write((uint64_t*)&cgen_var_839, 1 * 8);
+    uint64_t cgen_var_840;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_840, 1);
+    stream->write((uint64_t*)&cgen_var_840, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_841 = (uint64_t)(uintptr_t)pRectCount;
+    stream->putBe64(cgen_var_841);
+    if (pRectCount)
+    {
+        stream->write((uint32_t*)pRectCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_842 = (uint64_t)(uintptr_t)pRects;
+    stream->putBe64(cgen_var_842);
+    if (pRects)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
+        {
+            marshal_VkRect2D(stream, (VkRect2D*)(pRects + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pRectCount;
+    check_pRectCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pRectCount)
+    {
+        if (!(check_pRectCount))
+        {
+            fprintf(stderr, "fatal: pRectCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pRectCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkRect2D* check_pRects;
+    check_pRects = (VkRect2D*)(uintptr_t)stream->getBe64();
+    if (pRects)
+    {
+        if (!(check_pRects))
+        {
+            fprintf(stderr, "fatal: pRects inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
+        {
+            unmarshal_VkRect2D(stream, (VkRect2D*)(pRects + i));
+        }
+    }
+    VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkAcquireNextImage2KHR(
+    VkDevice device,
+    const VkAcquireNextImageInfoKHR* pAcquireInfo,
+    uint32_t* pImageIndex)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkAcquireNextImageInfoKHR* local_pAcquireInfo;
+    local_device = device;
+    local_pAcquireInfo = nullptr;
+    if (pAcquireInfo)
+    {
+        local_pAcquireInfo = (VkAcquireNextImageInfoKHR*)pool->alloc(sizeof(const VkAcquireNextImageInfoKHR));
+        deepcopy_VkAcquireNextImageInfoKHR(pool, pAcquireInfo, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_845;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_845, 1);
+        countingStream->write((uint64_t*)&cgen_var_845, 1 * 8);
+        marshal_VkAcquireNextImageInfoKHR(countingStream, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
+        countingStream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkAcquireNextImage2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkAcquireNextImage2KHR = OP_vkAcquireNextImage2KHR;
+    stream->write(&opcode_vkAcquireNextImage2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkAcquireNextImage2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_846;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_846, 1);
+    stream->write((uint64_t*)&cgen_var_846, 1 * 8);
+    marshal_VkAcquireNextImageInfoKHR(stream, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
+    stream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
+    stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
+    VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkAcquireNextImage2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkAcquireNextImage2KHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_display
+VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pPropertyCount,
+    VkDisplayPropertiesKHR* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_847;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_847, 1);
+        countingStream->write((uint64_t*)&cgen_var_847, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_848 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_848);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_849 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_849);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkDisplayPropertiesKHR(countingStream, (VkDisplayPropertiesKHR*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceDisplayPropertiesKHR = OP_vkGetPhysicalDeviceDisplayPropertiesKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_850;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_850, 1);
+    stream->write((uint64_t*)&cgen_var_850, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_851 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_851);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_852 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_852);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkDisplayPropertiesKHR(stream, (VkDisplayPropertiesKHR*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkDisplayPropertiesKHR* check_pProperties;
+    check_pProperties = (VkDisplayPropertiesKHR*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkDisplayPropertiesKHR(stream, (VkDisplayPropertiesKHR*)(pProperties + i));
+        }
+    }
+    VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pPropertyCount,
+    VkDisplayPlanePropertiesKHR* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_855;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_855, 1);
+        countingStream->write((uint64_t*)&cgen_var_855, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_856 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_856);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_857 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_857);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkDisplayPlanePropertiesKHR(countingStream, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_858;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_858, 1);
+    stream->write((uint64_t*)&cgen_var_858, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_859 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_859);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_860 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_860);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkDisplayPlanePropertiesKHR(stream, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkDisplayPlanePropertiesKHR* check_pProperties;
+    check_pProperties = (VkDisplayPlanePropertiesKHR*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkDisplayPlanePropertiesKHR(stream, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
+        }
+    }
+    VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t planeIndex,
+    uint32_t* pDisplayCount,
+    VkDisplayKHR* pDisplays)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    uint32_t local_planeIndex;
+    local_physicalDevice = physicalDevice;
+    local_planeIndex = planeIndex;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_863;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_863, 1);
+        countingStream->write((uint64_t*)&cgen_var_863, 1 * 8);
+        countingStream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_864 = (uint64_t)(uintptr_t)pDisplayCount;
+        countingStream->putBe64(cgen_var_864);
+        if (pDisplayCount)
+        {
+            countingStream->write((uint32_t*)pDisplayCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_865 = (uint64_t)(uintptr_t)pDisplays;
+        countingStream->putBe64(cgen_var_865);
+        if (pDisplays)
+        {
+            if ((*(pDisplayCount)))
+            {
+                uint64_t* cgen_var_866;
+                countingStream->alloc((void**)&cgen_var_866, (*(pDisplayCount)) * 8);
+                countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_866, (*(pDisplayCount)));
+                countingStream->write((uint64_t*)cgen_var_866, (*(pDisplayCount)) * 8);
+            }
+        }
+    }
+    uint32_t packetSize_vkGetDisplayPlaneSupportedDisplaysKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDisplayPlaneSupportedDisplaysKHR = OP_vkGetDisplayPlaneSupportedDisplaysKHR;
+    stream->write(&opcode_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t));
+    uint64_t cgen_var_867;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_867, 1);
+    stream->write((uint64_t*)&cgen_var_867, 1 * 8);
+    stream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_868 = (uint64_t)(uintptr_t)pDisplayCount;
+    stream->putBe64(cgen_var_868);
+    if (pDisplayCount)
+    {
+        stream->write((uint32_t*)pDisplayCount, sizeof(uint32_t));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    // WARNING PTR CHECK
+    uint64_t cgen_var_869 = (uint64_t)(uintptr_t)pDisplays;
+    stream->putBe64(cgen_var_869);
+    if (pDisplays)
+    {
+        if ((*(pDisplayCount)))
+        {
+            uint64_t* cgen_var_870;
+            stream->alloc((void**)&cgen_var_870, (*(pDisplayCount)) * 8);
+            stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_870, (*(pDisplayCount)));
+            stream->write((uint64_t*)cgen_var_870, (*(pDisplayCount)) * 8);
+        }
+    }
+    stream->setHandleMapping(resources->unwrapMapping());
+    // WARNING PTR CHECK
+    uint32_t* check_pDisplayCount;
+    check_pDisplayCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pDisplayCount)
+    {
+        if (!(check_pDisplayCount))
+        {
+            fprintf(stderr, "fatal: pDisplayCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pDisplayCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkDisplayKHR* check_pDisplays;
+    check_pDisplays = (VkDisplayKHR*)(uintptr_t)stream->getBe64();
+    if (pDisplays)
+    {
+        if (!(check_pDisplays))
+        {
+            fprintf(stderr, "fatal: pDisplays inconsistent between guest and host\n");
+        }
+        if ((*(pDisplayCount)))
+        {
+            uint64_t* cgen_var_873;
+            stream->alloc((void**)&cgen_var_873, (*(pDisplayCount)) * 8);
+            stream->read((uint64_t*)cgen_var_873, (*(pDisplayCount)) * 8);
+            stream->handleMapping()->mapHandles_u64_VkDisplayKHR(cgen_var_873, (VkDisplayKHR*)pDisplays, (*(pDisplayCount)));
+        }
+    }
+    VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDisplayModePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    VkDisplayKHR display,
+    uint32_t* pPropertyCount,
+    VkDisplayModePropertiesKHR* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkDisplayKHR local_display;
+    local_physicalDevice = physicalDevice;
+    local_display = display;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_874;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_874, 1);
+        countingStream->write((uint64_t*)&cgen_var_874, 1 * 8);
+        uint64_t cgen_var_875;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_875, 1);
+        countingStream->write((uint64_t*)&cgen_var_875, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_876 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_876);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_877 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_877);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkDisplayModePropertiesKHR(countingStream, (VkDisplayModePropertiesKHR*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetDisplayModePropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDisplayModePropertiesKHR = OP_vkGetDisplayModePropertiesKHR;
+    stream->write(&opcode_vkGetDisplayModePropertiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDisplayModePropertiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_878;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_878, 1);
+    stream->write((uint64_t*)&cgen_var_878, 1 * 8);
+    uint64_t cgen_var_879;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_879, 1);
+    stream->write((uint64_t*)&cgen_var_879, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_880 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_880);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_881 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_881);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkDisplayModePropertiesKHR(stream, (VkDisplayModePropertiesKHR*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkDisplayModePropertiesKHR* check_pProperties;
+    check_pProperties = (VkDisplayModePropertiesKHR*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkDisplayModePropertiesKHR(stream, (VkDisplayModePropertiesKHR*)(pProperties + i));
+        }
+    }
+    VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetDisplayModePropertiesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetDisplayModePropertiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateDisplayModeKHR(
+    VkPhysicalDevice physicalDevice,
+    VkDisplayKHR display,
+    const VkDisplayModeCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDisplayModeKHR* pMode)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkDisplayKHR local_display;
+    VkDisplayModeCreateInfoKHR* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_physicalDevice = physicalDevice;
+    local_display = display;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDisplayModeCreateInfoKHR*)pool->alloc(sizeof(const VkDisplayModeCreateInfoKHR));
+        deepcopy_VkDisplayModeCreateInfoKHR(pool, pCreateInfo, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_884;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_884, 1);
+        countingStream->write((uint64_t*)&cgen_var_884, 1 * 8);
+        uint64_t cgen_var_885;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_885, 1);
+        countingStream->write((uint64_t*)&cgen_var_885, 1 * 8);
+        marshal_VkDisplayModeCreateInfoKHR(countingStream, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_886 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_886);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_887;
+        countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_887, 1);
+        countingStream->write((uint64_t*)&cgen_var_887, 8);
+    }
+    uint32_t packetSize_vkCreateDisplayModeKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateDisplayModeKHR = OP_vkCreateDisplayModeKHR;
+    stream->write(&opcode_vkCreateDisplayModeKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateDisplayModeKHR, sizeof(uint32_t));
+    uint64_t cgen_var_888;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_888, 1);
+    stream->write((uint64_t*)&cgen_var_888, 1 * 8);
+    uint64_t cgen_var_889;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_889, 1);
+    stream->write((uint64_t*)&cgen_var_889, 1 * 8);
+    marshal_VkDisplayModeCreateInfoKHR(stream, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_890 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_890);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_891;
+    stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_891, 1);
+    stream->write((uint64_t*)&cgen_var_891, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_892;
+    stream->read((uint64_t*)&cgen_var_892, 8);
+    stream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_892, (VkDisplayModeKHR*)pMode, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateDisplayModeKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateDisplayModeKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDisplayPlaneCapabilitiesKHR(
+    VkPhysicalDevice physicalDevice,
+    VkDisplayModeKHR mode,
+    uint32_t planeIndex,
+    VkDisplayPlaneCapabilitiesKHR* pCapabilities)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkDisplayModeKHR local_mode;
+    uint32_t local_planeIndex;
+    local_physicalDevice = physicalDevice;
+    local_mode = mode;
+    local_planeIndex = planeIndex;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_893;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_893, 1);
+        countingStream->write((uint64_t*)&cgen_var_893, 1 * 8);
+        uint64_t cgen_var_894;
+        countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_894, 1);
+        countingStream->write((uint64_t*)&cgen_var_894, 1 * 8);
+        countingStream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
+        marshal_VkDisplayPlaneCapabilitiesKHR(countingStream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
+    }
+    uint32_t packetSize_vkGetDisplayPlaneCapabilitiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDisplayPlaneCapabilitiesKHR = OP_vkGetDisplayPlaneCapabilitiesKHR;
+    stream->write(&opcode_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_895;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_895, 1);
+    stream->write((uint64_t*)&cgen_var_895, 1 * 8);
+    uint64_t cgen_var_896;
+    stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_896, 1);
+    stream->write((uint64_t*)&cgen_var_896, 1 * 8);
+    stream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
+    marshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
+    unmarshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
+    VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetDisplayPlaneCapabilitiesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateDisplayPlaneSurfaceKHR(
+    VkInstance instance,
+    const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkDisplaySurfaceCreateInfoKHR* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDisplaySurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkDisplaySurfaceCreateInfoKHR));
+        deepcopy_VkDisplaySurfaceCreateInfoKHR(pool, pCreateInfo, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_897;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_897, 1);
+        countingStream->write((uint64_t*)&cgen_var_897, 1 * 8);
+        marshal_VkDisplaySurfaceCreateInfoKHR(countingStream, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_898 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_898);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_899;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_899, 1);
+        countingStream->write((uint64_t*)&cgen_var_899, 8);
+    }
+    uint32_t packetSize_vkCreateDisplayPlaneSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateDisplayPlaneSurfaceKHR = OP_vkCreateDisplayPlaneSurfaceKHR;
+    stream->write(&opcode_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t));
+    uint64_t cgen_var_900;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_900, 1);
+    stream->write((uint64_t*)&cgen_var_900, 1 * 8);
+    marshal_VkDisplaySurfaceCreateInfoKHR(stream, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_901 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_901);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_902;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_902, 1);
+    stream->write((uint64_t*)&cgen_var_902, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_903;
+    stream->read((uint64_t*)&cgen_var_903, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_903, (VkSurfaceKHR*)pSurface, 1);
+    VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateDisplayPlaneSurfaceKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_display_swapchain
+VkResult VkEncoder::vkCreateSharedSwapchainsKHR(
+    VkDevice device,
+    uint32_t swapchainCount,
+    const VkSwapchainCreateInfoKHR* pCreateInfos,
+    const VkAllocationCallbacks* pAllocator,
+    VkSwapchainKHR* pSwapchains)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_swapchainCount;
+    VkSwapchainCreateInfoKHR* local_pCreateInfos;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_swapchainCount = swapchainCount;
+    local_pCreateInfos = nullptr;
+    if (pCreateInfos)
+    {
+        local_pCreateInfos = (VkSwapchainCreateInfoKHR*)pool->alloc(((swapchainCount)) * sizeof(const VkSwapchainCreateInfoKHR));
+        for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+        {
+            deepcopy_VkSwapchainCreateInfoKHR(pool, pCreateInfos + i, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
+        }
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_904;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_904, 1);
+        countingStream->write((uint64_t*)&cgen_var_904, 1 * 8);
+        countingStream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+        {
+            marshal_VkSwapchainCreateInfoKHR(countingStream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_905 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_905);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        if (((swapchainCount)))
+        {
+            uint64_t* cgen_var_906;
+            countingStream->alloc((void**)&cgen_var_906, ((swapchainCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_906, ((swapchainCount)));
+            countingStream->write((uint64_t*)cgen_var_906, ((swapchainCount)) * 8);
+        }
+    }
+    uint32_t packetSize_vkCreateSharedSwapchainsKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateSharedSwapchainsKHR = OP_vkCreateSharedSwapchainsKHR;
+    stream->write(&opcode_vkCreateSharedSwapchainsKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateSharedSwapchainsKHR, sizeof(uint32_t));
+    uint64_t cgen_var_907;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_907, 1);
+    stream->write((uint64_t*)&cgen_var_907, 1 * 8);
+    stream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+    {
+        marshal_VkSwapchainCreateInfoKHR(stream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_908 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_908);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    if (((swapchainCount)))
+    {
+        uint64_t* cgen_var_909;
+        stream->alloc((void**)&cgen_var_909, ((swapchainCount)) * 8);
+        stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_909, ((swapchainCount)));
+        stream->write((uint64_t*)cgen_var_909, ((swapchainCount)) * 8);
+    }
+    stream->setHandleMapping(resources->unwrapMapping());
+    if (((swapchainCount)))
+    {
+        uint64_t* cgen_var_910;
+        stream->alloc((void**)&cgen_var_910, ((swapchainCount)) * 8);
+        stream->read((uint64_t*)cgen_var_910, ((swapchainCount)) * 8);
+        stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_910, (VkSwapchainKHR*)pSwapchains, ((swapchainCount)));
+    }
+    VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateSharedSwapchainsKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateSharedSwapchainsKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_xlib_surface
+VkResult VkEncoder::vkCreateXlibSurfaceKHR(
+    VkInstance instance,
+    const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkXlibSurfaceCreateInfoKHR* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkXlibSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXlibSurfaceCreateInfoKHR));
+        deepcopy_VkXlibSurfaceCreateInfoKHR(pool, pCreateInfo, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_911;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_911, 1);
+        countingStream->write((uint64_t*)&cgen_var_911, 1 * 8);
+        marshal_VkXlibSurfaceCreateInfoKHR(countingStream, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_912 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_912);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_913;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_913, 1);
+        countingStream->write((uint64_t*)&cgen_var_913, 8);
+    }
+    uint32_t packetSize_vkCreateXlibSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateXlibSurfaceKHR = OP_vkCreateXlibSurfaceKHR;
+    stream->write(&opcode_vkCreateXlibSurfaceKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateXlibSurfaceKHR, sizeof(uint32_t));
+    uint64_t cgen_var_914;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_914, 1);
+    stream->write((uint64_t*)&cgen_var_914, 1 * 8);
+    marshal_VkXlibSurfaceCreateInfoKHR(stream, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_915 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_915);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_916;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_916, 1);
+    stream->write((uint64_t*)&cgen_var_916, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_917;
+    stream->read((uint64_t*)&cgen_var_917, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_917, (VkSurfaceKHR*)pSurface, 1);
+    VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateXlibSurfaceKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateXlibSurfaceKHR_VkResult_return;
+}
+
+VkBool32 VkEncoder::vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex,
+    Display* dpy,
+    VisualID visualID)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    uint32_t local_queueFamilyIndex;
+    VisualID local_visualID;
+    local_physicalDevice = physicalDevice;
+    local_queueFamilyIndex = queueFamilyIndex;
+    local_visualID = visualID;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_918;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_918, 1);
+        countingStream->write((uint64_t*)&cgen_var_918, 1 * 8);
+        countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+        countingStream->write((Display*)dpy, sizeof(Display));
+        countingStream->write((VisualID*)&local_visualID, sizeof(VisualID));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR = OP_vkGetPhysicalDeviceXlibPresentationSupportKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t));
+    uint64_t cgen_var_919;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_919, 1);
+    stream->write((uint64_t*)&cgen_var_919, 1 * 8);
+    stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+    stream->write((Display*)dpy, sizeof(Display));
+    stream->write((VisualID*)&local_visualID, sizeof(VisualID));
+    stream->read((Display*)dpy, sizeof(Display));
+    VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    stream->read(&vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
+}
+
+#endif
+#ifdef VK_KHR_xcb_surface
+VkResult VkEncoder::vkCreateXcbSurfaceKHR(
+    VkInstance instance,
+    const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkXcbSurfaceCreateInfoKHR* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkXcbSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXcbSurfaceCreateInfoKHR));
+        deepcopy_VkXcbSurfaceCreateInfoKHR(pool, pCreateInfo, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_920;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_920, 1);
+        countingStream->write((uint64_t*)&cgen_var_920, 1 * 8);
+        marshal_VkXcbSurfaceCreateInfoKHR(countingStream, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_921 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_921);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_922;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_922, 1);
+        countingStream->write((uint64_t*)&cgen_var_922, 8);
+    }
+    uint32_t packetSize_vkCreateXcbSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateXcbSurfaceKHR = OP_vkCreateXcbSurfaceKHR;
+    stream->write(&opcode_vkCreateXcbSurfaceKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateXcbSurfaceKHR, sizeof(uint32_t));
+    uint64_t cgen_var_923;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_923, 1);
+    stream->write((uint64_t*)&cgen_var_923, 1 * 8);
+    marshal_VkXcbSurfaceCreateInfoKHR(stream, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_924 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_924);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_925;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_925, 1);
+    stream->write((uint64_t*)&cgen_var_925, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_926;
+    stream->read((uint64_t*)&cgen_var_926, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_926, (VkSurfaceKHR*)pSurface, 1);
+    VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateXcbSurfaceKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateXcbSurfaceKHR_VkResult_return;
+}
+
+VkBool32 VkEncoder::vkGetPhysicalDeviceXcbPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex,
+    xcb_connection_t* connection,
+    xcb_visualid_t visual_id)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    uint32_t local_queueFamilyIndex;
+    xcb_visualid_t local_visual_id;
+    local_physicalDevice = physicalDevice;
+    local_queueFamilyIndex = queueFamilyIndex;
+    local_visual_id = visual_id;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_927;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_927, 1);
+        countingStream->write((uint64_t*)&cgen_var_927, 1 * 8);
+        countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+        countingStream->write((xcb_connection_t*)connection, sizeof(xcb_connection_t));
+        countingStream->write((xcb_visualid_t*)&local_visual_id, sizeof(xcb_visualid_t));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR = OP_vkGetPhysicalDeviceXcbPresentationSupportKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t));
+    uint64_t cgen_var_928;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_928, 1);
+    stream->write((uint64_t*)&cgen_var_928, 1 * 8);
+    stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+    stream->write((xcb_connection_t*)connection, sizeof(xcb_connection_t));
+    stream->write((xcb_visualid_t*)&local_visual_id, sizeof(xcb_visualid_t));
+    stream->read((xcb_connection_t*)connection, sizeof(xcb_connection_t));
+    VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    stream->read(&vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
+}
+
+#endif
+#ifdef VK_KHR_wayland_surface
+VkResult VkEncoder::vkCreateWaylandSurfaceKHR(
+    VkInstance instance,
+    const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkWaylandSurfaceCreateInfoKHR* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkWaylandSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWaylandSurfaceCreateInfoKHR));
+        deepcopy_VkWaylandSurfaceCreateInfoKHR(pool, pCreateInfo, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_929;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_929, 1);
+        countingStream->write((uint64_t*)&cgen_var_929, 1 * 8);
+        marshal_VkWaylandSurfaceCreateInfoKHR(countingStream, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_930 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_930);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_931;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_931, 1);
+        countingStream->write((uint64_t*)&cgen_var_931, 8);
+    }
+    uint32_t packetSize_vkCreateWaylandSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateWaylandSurfaceKHR = OP_vkCreateWaylandSurfaceKHR;
+    stream->write(&opcode_vkCreateWaylandSurfaceKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateWaylandSurfaceKHR, sizeof(uint32_t));
+    uint64_t cgen_var_932;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_932, 1);
+    stream->write((uint64_t*)&cgen_var_932, 1 * 8);
+    marshal_VkWaylandSurfaceCreateInfoKHR(stream, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_933 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_933);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_934;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_934, 1);
+    stream->write((uint64_t*)&cgen_var_934, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_935;
+    stream->read((uint64_t*)&cgen_var_935, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_935, (VkSurfaceKHR*)pSurface, 1);
+    VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateWaylandSurfaceKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateWaylandSurfaceKHR_VkResult_return;
+}
+
+VkBool32 VkEncoder::vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex,
+    wl_display* display)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    uint32_t local_queueFamilyIndex;
+    local_physicalDevice = physicalDevice;
+    local_queueFamilyIndex = queueFamilyIndex;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_936;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_936, 1);
+        countingStream->write((uint64_t*)&cgen_var_936, 1 * 8);
+        countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+        countingStream->write((wl_display*)display, sizeof(wl_display));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR = OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t));
+    uint64_t cgen_var_937;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_937, 1);
+    stream->write((uint64_t*)&cgen_var_937, 1 * 8);
+    stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+    stream->write((wl_display*)display, sizeof(wl_display));
+    stream->read((wl_display*)display, sizeof(wl_display));
+    VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    stream->read(&vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
+}
+
+#endif
+#ifdef VK_KHR_mir_surface
+VkResult VkEncoder::vkCreateMirSurfaceKHR(
+    VkInstance instance,
+    const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkMirSurfaceCreateInfoKHR* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkMirSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkMirSurfaceCreateInfoKHR));
+        deepcopy_VkMirSurfaceCreateInfoKHR(pool, pCreateInfo, (VkMirSurfaceCreateInfoKHR*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_938;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_938, 1);
+        countingStream->write((uint64_t*)&cgen_var_938, 1 * 8);
+        marshal_VkMirSurfaceCreateInfoKHR(countingStream, (VkMirSurfaceCreateInfoKHR*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_939 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_939);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_940;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_940, 1);
+        countingStream->write((uint64_t*)&cgen_var_940, 8);
+    }
+    uint32_t packetSize_vkCreateMirSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateMirSurfaceKHR = OP_vkCreateMirSurfaceKHR;
+    stream->write(&opcode_vkCreateMirSurfaceKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateMirSurfaceKHR, sizeof(uint32_t));
+    uint64_t cgen_var_941;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_941, 1);
+    stream->write((uint64_t*)&cgen_var_941, 1 * 8);
+    marshal_VkMirSurfaceCreateInfoKHR(stream, (VkMirSurfaceCreateInfoKHR*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_942 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_942);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_943;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_943, 1);
+    stream->write((uint64_t*)&cgen_var_943, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_944;
+    stream->read((uint64_t*)&cgen_var_944, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_944, (VkSurfaceKHR*)pSurface, 1);
+    VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateMirSurfaceKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateMirSurfaceKHR_VkResult_return;
+}
+
+VkBool32 VkEncoder::vkGetPhysicalDeviceMirPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex,
+    MirConnection* connection)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    uint32_t local_queueFamilyIndex;
+    local_physicalDevice = physicalDevice;
+    local_queueFamilyIndex = queueFamilyIndex;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_945;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_945, 1);
+        countingStream->write((uint64_t*)&cgen_var_945, 1 * 8);
+        countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+        countingStream->write((MirConnection*)connection, sizeof(MirConnection));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceMirPresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceMirPresentationSupportKHR = OP_vkGetPhysicalDeviceMirPresentationSupportKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceMirPresentationSupportKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceMirPresentationSupportKHR, sizeof(uint32_t));
+    uint64_t cgen_var_946;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_946, 1);
+    stream->write((uint64_t*)&cgen_var_946, 1 * 8);
+    stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+    stream->write((MirConnection*)connection, sizeof(MirConnection));
+    stream->read((MirConnection*)connection, sizeof(MirConnection));
+    VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    stream->read(&vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return;
+}
+
+#endif
+#ifdef VK_KHR_android_surface
+VkResult VkEncoder::vkCreateAndroidSurfaceKHR(
+    VkInstance instance,
+    const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkAndroidSurfaceCreateInfoKHR* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkAndroidSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkAndroidSurfaceCreateInfoKHR));
+        deepcopy_VkAndroidSurfaceCreateInfoKHR(pool, pCreateInfo, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_947;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_947, 1);
+        countingStream->write((uint64_t*)&cgen_var_947, 1 * 8);
+        marshal_VkAndroidSurfaceCreateInfoKHR(countingStream, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_948 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_948);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_949;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_949, 1);
+        countingStream->write((uint64_t*)&cgen_var_949, 8);
+    }
+    uint32_t packetSize_vkCreateAndroidSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateAndroidSurfaceKHR = OP_vkCreateAndroidSurfaceKHR;
+    stream->write(&opcode_vkCreateAndroidSurfaceKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateAndroidSurfaceKHR, sizeof(uint32_t));
+    uint64_t cgen_var_950;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_950, 1);
+    stream->write((uint64_t*)&cgen_var_950, 1 * 8);
+    marshal_VkAndroidSurfaceCreateInfoKHR(stream, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_951 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_951);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_952;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_952, 1);
+    stream->write((uint64_t*)&cgen_var_952, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_953;
+    stream->read((uint64_t*)&cgen_var_953, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_953, (VkSurfaceKHR*)pSurface, 1);
+    VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateAndroidSurfaceKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateAndroidSurfaceKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_win32_surface
+VkResult VkEncoder::vkCreateWin32SurfaceKHR(
+    VkInstance instance,
+    const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkWin32SurfaceCreateInfoKHR* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkWin32SurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWin32SurfaceCreateInfoKHR));
+        deepcopy_VkWin32SurfaceCreateInfoKHR(pool, pCreateInfo, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_954;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_954, 1);
+        countingStream->write((uint64_t*)&cgen_var_954, 1 * 8);
+        marshal_VkWin32SurfaceCreateInfoKHR(countingStream, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_955 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_955);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_956;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_956, 1);
+        countingStream->write((uint64_t*)&cgen_var_956, 8);
+    }
+    uint32_t packetSize_vkCreateWin32SurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateWin32SurfaceKHR = OP_vkCreateWin32SurfaceKHR;
+    stream->write(&opcode_vkCreateWin32SurfaceKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateWin32SurfaceKHR, sizeof(uint32_t));
+    uint64_t cgen_var_957;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_957, 1);
+    stream->write((uint64_t*)&cgen_var_957, 1 * 8);
+    marshal_VkWin32SurfaceCreateInfoKHR(stream, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_958 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_958);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_959;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_959, 1);
+    stream->write((uint64_t*)&cgen_var_959, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_960;
+    stream->read((uint64_t*)&cgen_var_960, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_960, (VkSurfaceKHR*)pSurface, 1);
+    VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateWin32SurfaceKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateWin32SurfaceKHR_VkResult_return;
+}
+
+VkBool32 VkEncoder::vkGetPhysicalDeviceWin32PresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t queueFamilyIndex)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    uint32_t local_queueFamilyIndex;
+    local_physicalDevice = physicalDevice;
+    local_queueFamilyIndex = queueFamilyIndex;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_961;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_961, 1);
+        countingStream->write((uint64_t*)&cgen_var_961, 1 * 8);
+        countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR = OP_vkGetPhysicalDeviceWin32PresentationSupportKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t));
+    uint64_t cgen_var_962;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_962, 1);
+    stream->write((uint64_t*)&cgen_var_962, 1 * 8);
+    stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+    VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    stream->read(&vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
+}
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+void VkEncoder::vkGetPhysicalDeviceFeatures2KHR(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceFeatures2* pFeatures)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_963;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_963, 1);
+        countingStream->write((uint64_t*)&cgen_var_963, 1 * 8);
+        marshal_VkPhysicalDeviceFeatures2(countingStream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceFeatures2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceFeatures2KHR = OP_vkGetPhysicalDeviceFeatures2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_964;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_964, 1);
+    stream->write((uint64_t*)&cgen_var_964, 1 * 8);
+    marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+    unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+}
+
+void VkEncoder::vkGetPhysicalDeviceProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceProperties2* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_965;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_965, 1);
+        countingStream->write((uint64_t*)&cgen_var_965, 1 * 8);
+        marshal_VkPhysicalDeviceProperties2(countingStream, (VkPhysicalDeviceProperties2*)(pProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceProperties2KHR = OP_vkGetPhysicalDeviceProperties2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_966;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_966, 1);
+    stream->write((uint64_t*)&cgen_var_966, 1 * 8);
+    marshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
+    unmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkFormatProperties2* pFormatProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkFormat local_format;
+    local_physicalDevice = physicalDevice;
+    local_format = format;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_967;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_967, 1);
+        countingStream->write((uint64_t*)&cgen_var_967, 1 * 8);
+        countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+        marshal_VkFormatProperties2(countingStream, (VkFormatProperties2*)(pFormatProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceFormatProperties2KHR = OP_vkGetPhysicalDeviceFormatProperties2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_968;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_968, 1);
+    stream->write((uint64_t*)&cgen_var_968, 1 * 8);
+    stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+    marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
+    unmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+    VkImageFormatProperties2* pImageFormatProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceImageFormatInfo2* local_pImageFormatInfo;
+    local_physicalDevice = physicalDevice;
+    local_pImageFormatInfo = nullptr;
+    if (pImageFormatInfo)
+    {
+        local_pImageFormatInfo = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceImageFormatInfo2));
+        deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, pImageFormatInfo, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_969;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_969, 1);
+        countingStream->write((uint64_t*)&cgen_var_969, 1 * 8);
+        marshal_VkPhysicalDeviceImageFormatInfo2(countingStream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+        marshal_VkImageFormatProperties2(countingStream, (VkImageFormatProperties2*)(pImageFormatProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2KHR = OP_vkGetPhysicalDeviceImageFormatProperties2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_970;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_970, 1);
+    stream->write((uint64_t*)&cgen_var_970, 1 * 8);
+    marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+    marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
+    unmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
+    VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
+}
+
+void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_971;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_971, 1);
+        countingStream->write((uint64_t*)&cgen_var_971, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_972 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+        countingStream->putBe64(cgen_var_972);
+        if (pQueueFamilyPropertyCount)
+        {
+            countingStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_973 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+        countingStream->putBe64(cgen_var_973);
+        if (pQueueFamilyProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+            {
+                marshal_VkQueueFamilyProperties2(countingStream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR = OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_974;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_974, 1);
+    stream->write((uint64_t*)&cgen_var_974, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_975 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+    stream->putBe64(cgen_var_975);
+    if (pQueueFamilyPropertyCount)
+    {
+        stream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_976 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+    stream->putBe64(cgen_var_976);
+    if (pQueueFamilyProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+        {
+            marshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pQueueFamilyPropertyCount;
+    check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pQueueFamilyPropertyCount)
+    {
+        if (!(check_pQueueFamilyPropertyCount))
+        {
+            fprintf(stderr, "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkQueueFamilyProperties2* check_pQueueFamilyProperties;
+    check_pQueueFamilyProperties = (VkQueueFamilyProperties2*)(uintptr_t)stream->getBe64();
+    if (pQueueFamilyProperties)
+    {
+        if (!(check_pQueueFamilyProperties))
+        {
+            fprintf(stderr, "fatal: pQueueFamilyProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+        {
+            unmarshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+        }
+    }
+}
+
+void VkEncoder::vkGetPhysicalDeviceMemoryProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_979;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_979, 1);
+        countingStream->write((uint64_t*)&cgen_var_979, 1 * 8);
+        marshal_VkPhysicalDeviceMemoryProperties2(countingStream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2KHR = OP_vkGetPhysicalDeviceMemoryProperties2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_980;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_980, 1);
+    stream->write((uint64_t*)&cgen_var_980, 1 * 8);
+    marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+    unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+    uint32_t* pPropertyCount,
+    VkSparseImageFormatProperties2* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceSparseImageFormatInfo2* local_pFormatInfo;
+    local_physicalDevice = physicalDevice;
+    local_pFormatInfo = nullptr;
+    if (pFormatInfo)
+    {
+        local_pFormatInfo = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
+        deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, pFormatInfo, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_981;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_981, 1);
+        countingStream->write((uint64_t*)&cgen_var_981, 1 * 8);
+        marshal_VkPhysicalDeviceSparseImageFormatInfo2(countingStream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_982 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_982);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_983 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_983);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkSparseImageFormatProperties2(countingStream, (VkSparseImageFormatProperties2*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_984;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_984, 1);
+    stream->write((uint64_t*)&cgen_var_984, 1 * 8);
+    marshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_985 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_985);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_986 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_986);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkSparseImageFormatProperties2* check_pProperties;
+    check_pProperties = (VkSparseImageFormatProperties2*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_KHR_device_group
+void VkEncoder::vkGetDeviceGroupPeerMemoryFeaturesKHR(
+    VkDevice device,
+    uint32_t heapIndex,
+    uint32_t localDeviceIndex,
+    uint32_t remoteDeviceIndex,
+    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_heapIndex;
+    uint32_t local_localDeviceIndex;
+    uint32_t local_remoteDeviceIndex;
+    local_device = device;
+    local_heapIndex = heapIndex;
+    local_localDeviceIndex = localDeviceIndex;
+    local_remoteDeviceIndex = remoteDeviceIndex;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_989;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_989, 1);
+        countingStream->write((uint64_t*)&cgen_var_989, 1 * 8);
+        countingStream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
+        countingStream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+    }
+    uint32_t packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR = OP_vkGetDeviceGroupPeerMemoryFeaturesKHR;
+    stream->write(&opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_990;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_990, 1);
+    stream->write((uint64_t*)&cgen_var_990, 1 * 8);
+    stream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
+    stream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+    stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+}
+
+void VkEncoder::vkCmdSetDeviceMaskKHR(
+    VkCommandBuffer commandBuffer,
+    uint32_t deviceMask)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_deviceMask;
+    local_commandBuffer = commandBuffer;
+    local_deviceMask = deviceMask;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_991;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_991, 1);
+        countingStream->write((uint64_t*)&cgen_var_991, 1 * 8);
+        countingStream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdSetDeviceMaskKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetDeviceMaskKHR = OP_vkCmdSetDeviceMaskKHR;
+    stream->write(&opcode_vkCmdSetDeviceMaskKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetDeviceMaskKHR, sizeof(uint32_t));
+    uint64_t cgen_var_992;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_992, 1);
+    stream->write((uint64_t*)&cgen_var_992, 1 * 8);
+    stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDispatchBaseKHR(
+    VkCommandBuffer commandBuffer,
+    uint32_t baseGroupX,
+    uint32_t baseGroupY,
+    uint32_t baseGroupZ,
+    uint32_t groupCountX,
+    uint32_t groupCountY,
+    uint32_t groupCountZ)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_baseGroupX;
+    uint32_t local_baseGroupY;
+    uint32_t local_baseGroupZ;
+    uint32_t local_groupCountX;
+    uint32_t local_groupCountY;
+    uint32_t local_groupCountZ;
+    local_commandBuffer = commandBuffer;
+    local_baseGroupX = baseGroupX;
+    local_baseGroupY = baseGroupY;
+    local_baseGroupZ = baseGroupZ;
+    local_groupCountX = groupCountX;
+    local_groupCountY = groupCountY;
+    local_groupCountZ = groupCountZ;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_993;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_993, 1);
+        countingStream->write((uint64_t*)&cgen_var_993, 1 * 8);
+        countingStream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDispatchBaseKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDispatchBaseKHR = OP_vkCmdDispatchBaseKHR;
+    stream->write(&opcode_vkCmdDispatchBaseKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDispatchBaseKHR, sizeof(uint32_t));
+    uint64_t cgen_var_994;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_994, 1);
+    stream->write((uint64_t*)&cgen_var_994, 1 * 8);
+    stream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+void VkEncoder::vkTrimCommandPoolKHR(
+    VkDevice device,
+    VkCommandPool commandPool,
+    VkCommandPoolTrimFlags flags)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkCommandPool local_commandPool;
+    VkCommandPoolTrimFlags local_flags;
+    local_device = device;
+    local_commandPool = commandPool;
+    local_flags = flags;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_995;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_995, 1);
+        countingStream->write((uint64_t*)&cgen_var_995, 1 * 8);
+        uint64_t cgen_var_996;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_996, 1);
+        countingStream->write((uint64_t*)&cgen_var_996, 1 * 8);
+        countingStream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
+    }
+    uint32_t packetSize_vkTrimCommandPoolKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkTrimCommandPoolKHR = OP_vkTrimCommandPoolKHR;
+    stream->write(&opcode_vkTrimCommandPoolKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkTrimCommandPoolKHR, sizeof(uint32_t));
+    uint64_t cgen_var_997;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_997, 1);
+    stream->write((uint64_t*)&cgen_var_997, 1 * 8);
+    uint64_t cgen_var_998;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_998, 1);
+    stream->write((uint64_t*)&cgen_var_998, 1 * 8);
+    stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
+}
+
+#endif
+#ifdef VK_KHR_device_group_creation
+VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR(
+    VkInstance instance,
+    uint32_t* pPhysicalDeviceGroupCount,
+    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    local_instance = instance;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_999;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_999, 1);
+        countingStream->write((uint64_t*)&cgen_var_999, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1000 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+        countingStream->putBe64(cgen_var_1000);
+        if (pPhysicalDeviceGroupCount)
+        {
+            countingStream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1001 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+        countingStream->putBe64(cgen_var_1001);
+        if (pPhysicalDeviceGroupProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+            {
+                marshal_VkPhysicalDeviceGroupProperties(countingStream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkEnumeratePhysicalDeviceGroupsKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkEnumeratePhysicalDeviceGroupsKHR = OP_vkEnumeratePhysicalDeviceGroupsKHR;
+    stream->write(&opcode_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1002;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1002, 1);
+    stream->write((uint64_t*)&cgen_var_1002, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1003 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+    stream->putBe64(cgen_var_1003);
+    if (pPhysicalDeviceGroupCount)
+    {
+        stream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1004 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+    stream->putBe64(cgen_var_1004);
+    if (pPhysicalDeviceGroupProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+        {
+            marshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPhysicalDeviceGroupCount;
+    check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPhysicalDeviceGroupCount)
+    {
+        if (!(check_pPhysicalDeviceGroupCount))
+        {
+            fprintf(stderr, "fatal: pPhysicalDeviceGroupCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkPhysicalDeviceGroupProperties* check_pPhysicalDeviceGroupProperties;
+    check_pPhysicalDeviceGroupProperties = (VkPhysicalDeviceGroupProperties*)(uintptr_t)stream->getBe64();
+    if (pPhysicalDeviceGroupProperties)
+    {
+        if (!(check_pPhysicalDeviceGroupProperties))
+        {
+            fprintf(stderr, "fatal: pPhysicalDeviceGroupProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+        {
+            unmarshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+        }
+    }
+    VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+void VkEncoder::vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+    VkExternalBufferProperties* pExternalBufferProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceExternalBufferInfo* local_pExternalBufferInfo;
+    local_physicalDevice = physicalDevice;
+    local_pExternalBufferInfo = nullptr;
+    if (pExternalBufferInfo)
+    {
+        local_pExternalBufferInfo = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalBufferInfo));
+        deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, pExternalBufferInfo, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1007;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1007, 1);
+        countingStream->write((uint64_t*)&cgen_var_1007, 1 * 8);
+        marshal_VkPhysicalDeviceExternalBufferInfo(countingStream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+        marshal_VkExternalBufferProperties(countingStream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR = OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1008;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1008, 1);
+    stream->write((uint64_t*)&cgen_var_1008, 1 * 8);
+    marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+    marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+    unmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+}
+
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+VkResult VkEncoder::vkGetMemoryWin32HandleKHR(
+    VkDevice device,
+    const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+    HANDLE* pHandle)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkMemoryGetWin32HandleInfoKHR* local_pGetWin32HandleInfo;
+    local_device = device;
+    local_pGetWin32HandleInfo = nullptr;
+    if (pGetWin32HandleInfo)
+    {
+        local_pGetWin32HandleInfo = (VkMemoryGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkMemoryGetWin32HandleInfoKHR));
+        deepcopy_VkMemoryGetWin32HandleInfoKHR(pool, pGetWin32HandleInfo, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1009;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1009, 1);
+        countingStream->write((uint64_t*)&cgen_var_1009, 1 * 8);
+        marshal_VkMemoryGetWin32HandleInfoKHR(countingStream, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+        countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
+    }
+    uint32_t packetSize_vkGetMemoryWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetMemoryWin32HandleKHR = OP_vkGetMemoryWin32HandleKHR;
+    stream->write(&opcode_vkGetMemoryWin32HandleKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetMemoryWin32HandleKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1010;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1010, 1);
+    stream->write((uint64_t*)&cgen_var_1010, 1 * 8);
+    marshal_VkMemoryGetWin32HandleInfoKHR(stream, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+    stream->write((HANDLE*)pHandle, sizeof(HANDLE));
+    stream->read((HANDLE*)pHandle, sizeof(HANDLE));
+    VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetMemoryWin32HandleKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetMemoryWin32HandleKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetMemoryWin32HandlePropertiesKHR(
+    VkDevice device,
+    VkExternalMemoryHandleTypeFlagBits handleType,
+    HANDLE handle,
+    VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkExternalMemoryHandleTypeFlagBits local_handleType;
+    HANDLE local_handle;
+    local_device = device;
+    local_handleType = handleType;
+    local_handle = handle;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1011;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1011, 1);
+        countingStream->write((uint64_t*)&cgen_var_1011, 1 * 8);
+        countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+        countingStream->write((HANDLE*)&local_handle, sizeof(HANDLE));
+        marshal_VkMemoryWin32HandlePropertiesKHR(countingStream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
+    }
+    uint32_t packetSize_vkGetMemoryWin32HandlePropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetMemoryWin32HandlePropertiesKHR = OP_vkGetMemoryWin32HandlePropertiesKHR;
+    stream->write(&opcode_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1012;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1012, 1);
+    stream->write((uint64_t*)&cgen_var_1012, 1 * 8);
+    stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+    stream->write((HANDLE*)&local_handle, sizeof(HANDLE));
+    marshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
+    unmarshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
+    VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetMemoryWin32HandlePropertiesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+VkResult VkEncoder::vkGetMemoryFdKHR(
+    VkDevice device,
+    const VkMemoryGetFdInfoKHR* pGetFdInfo,
+    int* pFd)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkMemoryGetFdInfoKHR* local_pGetFdInfo;
+    local_device = device;
+    local_pGetFdInfo = nullptr;
+    if (pGetFdInfo)
+    {
+        local_pGetFdInfo = (VkMemoryGetFdInfoKHR*)pool->alloc(sizeof(const VkMemoryGetFdInfoKHR));
+        deepcopy_VkMemoryGetFdInfoKHR(pool, pGetFdInfo, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1013;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1013, 1);
+        countingStream->write((uint64_t*)&cgen_var_1013, 1 * 8);
+        marshal_VkMemoryGetFdInfoKHR(countingStream, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
+        countingStream->write((int*)pFd, sizeof(int));
+    }
+    uint32_t packetSize_vkGetMemoryFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetMemoryFdKHR = OP_vkGetMemoryFdKHR;
+    stream->write(&opcode_vkGetMemoryFdKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetMemoryFdKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1014;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1014, 1);
+    stream->write((uint64_t*)&cgen_var_1014, 1 * 8);
+    marshal_VkMemoryGetFdInfoKHR(stream, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
+    stream->write((int*)pFd, sizeof(int));
+    stream->read((int*)pFd, sizeof(int));
+    VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetMemoryFdKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetMemoryFdKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetMemoryFdPropertiesKHR(
+    VkDevice device,
+    VkExternalMemoryHandleTypeFlagBits handleType,
+    int fd,
+    VkMemoryFdPropertiesKHR* pMemoryFdProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkExternalMemoryHandleTypeFlagBits local_handleType;
+    int local_fd;
+    local_device = device;
+    local_handleType = handleType;
+    local_fd = fd;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1015;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1015, 1);
+        countingStream->write((uint64_t*)&cgen_var_1015, 1 * 8);
+        countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+        countingStream->write((int*)&local_fd, sizeof(int));
+        marshal_VkMemoryFdPropertiesKHR(countingStream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
+    }
+    uint32_t packetSize_vkGetMemoryFdPropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetMemoryFdPropertiesKHR = OP_vkGetMemoryFdPropertiesKHR;
+    stream->write(&opcode_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1016;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1016, 1);
+    stream->write((uint64_t*)&cgen_var_1016, 1 * 8);
+    stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+    stream->write((int*)&local_fd, sizeof(int));
+    marshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
+    unmarshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
+    VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetMemoryFdPropertiesKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetMemoryFdPropertiesKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+void VkEncoder::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceExternalSemaphoreInfo* local_pExternalSemaphoreInfo;
+    local_physicalDevice = physicalDevice;
+    local_pExternalSemaphoreInfo = nullptr;
+    if (pExternalSemaphoreInfo)
+    {
+        local_pExternalSemaphoreInfo = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
+        deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, pExternalSemaphoreInfo, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1017;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1017, 1);
+        countingStream->write((uint64_t*)&cgen_var_1017, 1 * 8);
+        marshal_VkPhysicalDeviceExternalSemaphoreInfo(countingStream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+        marshal_VkExternalSemaphoreProperties(countingStream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1018;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1018, 1);
+    stream->write((uint64_t*)&cgen_var_1018, 1 * 8);
+    marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+    marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+    unmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+VkResult VkEncoder::vkImportSemaphoreWin32HandleKHR(
+    VkDevice device,
+    const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImportSemaphoreWin32HandleInfoKHR* local_pImportSemaphoreWin32HandleInfo;
+    local_device = device;
+    local_pImportSemaphoreWin32HandleInfo = nullptr;
+    if (pImportSemaphoreWin32HandleInfo)
+    {
+        local_pImportSemaphoreWin32HandleInfo = (VkImportSemaphoreWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreWin32HandleInfoKHR));
+        deepcopy_VkImportSemaphoreWin32HandleInfoKHR(pool, pImportSemaphoreWin32HandleInfo, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1019;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1019, 1);
+        countingStream->write((uint64_t*)&cgen_var_1019, 1 * 8);
+        marshal_VkImportSemaphoreWin32HandleInfoKHR(countingStream, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
+    }
+    uint32_t packetSize_vkImportSemaphoreWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkImportSemaphoreWin32HandleKHR = OP_vkImportSemaphoreWin32HandleKHR;
+    stream->write(&opcode_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1020;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1020, 1);
+    stream->write((uint64_t*)&cgen_var_1020, 1 * 8);
+    marshal_VkImportSemaphoreWin32HandleInfoKHR(stream, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
+    VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkImportSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkImportSemaphoreWin32HandleKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetSemaphoreWin32HandleKHR(
+    VkDevice device,
+    const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+    HANDLE* pHandle)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSemaphoreGetWin32HandleInfoKHR* local_pGetWin32HandleInfo;
+    local_device = device;
+    local_pGetWin32HandleInfo = nullptr;
+    if (pGetWin32HandleInfo)
+    {
+        local_pGetWin32HandleInfo = (VkSemaphoreGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetWin32HandleInfoKHR));
+        deepcopy_VkSemaphoreGetWin32HandleInfoKHR(pool, pGetWin32HandleInfo, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1021;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1021, 1);
+        countingStream->write((uint64_t*)&cgen_var_1021, 1 * 8);
+        marshal_VkSemaphoreGetWin32HandleInfoKHR(countingStream, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+        countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
+    }
+    uint32_t packetSize_vkGetSemaphoreWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetSemaphoreWin32HandleKHR = OP_vkGetSemaphoreWin32HandleKHR;
+    stream->write(&opcode_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1022;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1022, 1);
+    stream->write((uint64_t*)&cgen_var_1022, 1 * 8);
+    marshal_VkSemaphoreGetWin32HandleInfoKHR(stream, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+    stream->write((HANDLE*)pHandle, sizeof(HANDLE));
+    stream->read((HANDLE*)pHandle, sizeof(HANDLE));
+    VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetSemaphoreWin32HandleKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+VkResult VkEncoder::vkImportSemaphoreFdKHR(
+    VkDevice device,
+    const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImportSemaphoreFdInfoKHR* local_pImportSemaphoreFdInfo;
+    local_device = device;
+    local_pImportSemaphoreFdInfo = nullptr;
+    if (pImportSemaphoreFdInfo)
+    {
+        local_pImportSemaphoreFdInfo = (VkImportSemaphoreFdInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreFdInfoKHR));
+        deepcopy_VkImportSemaphoreFdInfoKHR(pool, pImportSemaphoreFdInfo, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1023;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1023, 1);
+        countingStream->write((uint64_t*)&cgen_var_1023, 1 * 8);
+        marshal_VkImportSemaphoreFdInfoKHR(countingStream, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
+    }
+    uint32_t packetSize_vkImportSemaphoreFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkImportSemaphoreFdKHR = OP_vkImportSemaphoreFdKHR;
+    stream->write(&opcode_vkImportSemaphoreFdKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkImportSemaphoreFdKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1024;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1024, 1);
+    stream->write((uint64_t*)&cgen_var_1024, 1 * 8);
+    marshal_VkImportSemaphoreFdInfoKHR(stream, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
+    VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkImportSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkImportSemaphoreFdKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetSemaphoreFdKHR(
+    VkDevice device,
+    const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+    int* pFd)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSemaphoreGetFdInfoKHR* local_pGetFdInfo;
+    local_device = device;
+    local_pGetFdInfo = nullptr;
+    if (pGetFdInfo)
+    {
+        local_pGetFdInfo = (VkSemaphoreGetFdInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetFdInfoKHR));
+        deepcopy_VkSemaphoreGetFdInfoKHR(pool, pGetFdInfo, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1025;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1025, 1);
+        countingStream->write((uint64_t*)&cgen_var_1025, 1 * 8);
+        marshal_VkSemaphoreGetFdInfoKHR(countingStream, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
+        countingStream->write((int*)pFd, sizeof(int));
+    }
+    uint32_t packetSize_vkGetSemaphoreFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetSemaphoreFdKHR = OP_vkGetSemaphoreFdKHR;
+    stream->write(&opcode_vkGetSemaphoreFdKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetSemaphoreFdKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1026;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1026, 1);
+    stream->write((uint64_t*)&cgen_var_1026, 1 * 8);
+    marshal_VkSemaphoreGetFdInfoKHR(stream, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
+    stream->write((int*)pFd, sizeof(int));
+    stream->read((int*)pFd, sizeof(int));
+    VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetSemaphoreFdKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void VkEncoder::vkCmdPushDescriptorSetKHR(
+    VkCommandBuffer commandBuffer,
+    VkPipelineBindPoint pipelineBindPoint,
+    VkPipelineLayout layout,
+    uint32_t set,
+    uint32_t descriptorWriteCount,
+    const VkWriteDescriptorSet* pDescriptorWrites)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkPipelineBindPoint local_pipelineBindPoint;
+    VkPipelineLayout local_layout;
+    uint32_t local_set;
+    uint32_t local_descriptorWriteCount;
+    VkWriteDescriptorSet* local_pDescriptorWrites;
+    local_commandBuffer = commandBuffer;
+    local_pipelineBindPoint = pipelineBindPoint;
+    local_layout = layout;
+    local_set = set;
+    local_descriptorWriteCount = descriptorWriteCount;
+    local_pDescriptorWrites = nullptr;
+    if (pDescriptorWrites)
+    {
+        local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
+        for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+        {
+            deepcopy_VkWriteDescriptorSet(pool, pDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1027;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1027, 1);
+        countingStream->write((uint64_t*)&cgen_var_1027, 1 * 8);
+        countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+        uint64_t cgen_var_1028;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1028, 1);
+        countingStream->write((uint64_t*)&cgen_var_1028, 1 * 8);
+        countingStream->write((uint32_t*)&local_set, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+        {
+            marshal_VkWriteDescriptorSet(countingStream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+        }
+    }
+    uint32_t packetSize_vkCmdPushDescriptorSetKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdPushDescriptorSetKHR = OP_vkCmdPushDescriptorSetKHR;
+    stream->write(&opcode_vkCmdPushDescriptorSetKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdPushDescriptorSetKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1029;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1029, 1);
+    stream->write((uint64_t*)&cgen_var_1029, 1 * 8);
+    stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    uint64_t cgen_var_1030;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1030, 1);
+    stream->write((uint64_t*)&cgen_var_1030, 1 * 8);
+    stream->write((uint32_t*)&local_set, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+    {
+        marshal_VkWriteDescriptorSet(stream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+    }
+}
+
+void VkEncoder::vkCmdPushDescriptorSetWithTemplateKHR(
+    VkCommandBuffer commandBuffer,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+    VkPipelineLayout layout,
+    uint32_t set,
+    const void* pData)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+    VkPipelineLayout local_layout;
+    uint32_t local_set;
+    void* local_pData;
+    local_commandBuffer = commandBuffer;
+    local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+    local_layout = layout;
+    local_set = set;
+    local_pData = nullptr;
+    if (pData)
+    {
+        local_pData = (void*)pool->dupArray(pData, sizeof(const uint8_t));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1031;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1031, 1);
+        countingStream->write((uint64_t*)&cgen_var_1031, 1 * 8);
+        uint64_t cgen_var_1032;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1032, 1);
+        countingStream->write((uint64_t*)&cgen_var_1032, 1 * 8);
+        uint64_t cgen_var_1033;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1033, 1);
+        countingStream->write((uint64_t*)&cgen_var_1033, 1 * 8);
+        countingStream->write((uint32_t*)&local_set, sizeof(uint32_t));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1034 = (uint64_t)(uintptr_t)local_pData;
+        countingStream->putBe64(cgen_var_1034);
+        if (local_pData)
+        {
+            countingStream->write((void*)local_pData, sizeof(uint8_t));
+        }
+    }
+    uint32_t packetSize_vkCmdPushDescriptorSetWithTemplateKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdPushDescriptorSetWithTemplateKHR = OP_vkCmdPushDescriptorSetWithTemplateKHR;
+    stream->write(&opcode_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1035;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1035, 1);
+    stream->write((uint64_t*)&cgen_var_1035, 1 * 8);
+    uint64_t cgen_var_1036;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1036, 1);
+    stream->write((uint64_t*)&cgen_var_1036, 1 * 8);
+    uint64_t cgen_var_1037;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1037, 1);
+    stream->write((uint64_t*)&cgen_var_1037, 1 * 8);
+    stream->write((uint32_t*)&local_set, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1038 = (uint64_t)(uintptr_t)local_pData;
+    stream->putBe64(cgen_var_1038);
+    if (local_pData)
+    {
+        stream->write((void*)local_pData, sizeof(uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+VkResult VkEncoder::vkCreateDescriptorUpdateTemplateKHR(
+    VkDevice device,
+    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorUpdateTemplateCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(sizeof(const VkDescriptorUpdateTemplateCreateInfo));
+        deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, pCreateInfo, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1039;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1039, 1);
+        countingStream->write((uint64_t*)&cgen_var_1039, 1 * 8);
+        marshal_VkDescriptorUpdateTemplateCreateInfo(countingStream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1040 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1040);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1041;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1041, 1);
+        countingStream->write((uint64_t*)&cgen_var_1041, 8);
+    }
+    uint32_t packetSize_vkCreateDescriptorUpdateTemplateKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateDescriptorUpdateTemplateKHR = OP_vkCreateDescriptorUpdateTemplateKHR;
+    stream->write(&opcode_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1042;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1042, 1);
+    stream->write((uint64_t*)&cgen_var_1042, 1 * 8);
+    marshal_VkDescriptorUpdateTemplateCreateInfo(stream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1043 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1043);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1044;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1044, 1);
+    stream->write((uint64_t*)&cgen_var_1044, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_1045;
+    stream->read((uint64_t*)&cgen_var_1045, 8);
+    stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_1045, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
+    VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateDescriptorUpdateTemplateKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDescriptorUpdateTemplateKHR(
+    VkDevice device,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1046;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1046, 1);
+        countingStream->write((uint64_t*)&cgen_var_1046, 1 * 8);
+        uint64_t cgen_var_1047;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1047, 1);
+        countingStream->write((uint64_t*)&cgen_var_1047, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1048 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1048);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyDescriptorUpdateTemplateKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyDescriptorUpdateTemplateKHR = OP_vkDestroyDescriptorUpdateTemplateKHR;
+    stream->write(&opcode_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1049;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1049, 1);
+    stream->write((uint64_t*)&cgen_var_1049, 1 * 8);
+    uint64_t cgen_var_1050;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1050, 1);
+    stream->write((uint64_t*)&cgen_var_1050, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1051 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1051);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+}
+
+void VkEncoder::vkUpdateDescriptorSetWithTemplateKHR(
+    VkDevice device,
+    VkDescriptorSet descriptorSet,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+    const void* pData)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorSet local_descriptorSet;
+    VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+    void* local_pData;
+    local_device = device;
+    local_descriptorSet = descriptorSet;
+    local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+    local_pData = nullptr;
+    if (pData)
+    {
+        local_pData = (void*)pool->dupArray(pData, sizeof(const uint8_t));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1052;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1052, 1);
+        countingStream->write((uint64_t*)&cgen_var_1052, 1 * 8);
+        uint64_t cgen_var_1053;
+        countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1053, 1);
+        countingStream->write((uint64_t*)&cgen_var_1053, 1 * 8);
+        uint64_t cgen_var_1054;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1054, 1);
+        countingStream->write((uint64_t*)&cgen_var_1054, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1055 = (uint64_t)(uintptr_t)local_pData;
+        countingStream->putBe64(cgen_var_1055);
+        if (local_pData)
+        {
+            countingStream->write((void*)local_pData, sizeof(uint8_t));
+        }
+    }
+    uint32_t packetSize_vkUpdateDescriptorSetWithTemplateKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkUpdateDescriptorSetWithTemplateKHR = OP_vkUpdateDescriptorSetWithTemplateKHR;
+    stream->write(&opcode_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1056;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1056, 1);
+    stream->write((uint64_t*)&cgen_var_1056, 1 * 8);
+    uint64_t cgen_var_1057;
+    stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1057, 1);
+    stream->write((uint64_t*)&cgen_var_1057, 1 * 8);
+    uint64_t cgen_var_1058;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1058, 1);
+    stream->write((uint64_t*)&cgen_var_1058, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1059 = (uint64_t)(uintptr_t)local_pData;
+    stream->putBe64(cgen_var_1059);
+    if (local_pData)
+    {
+        stream->write((void*)local_pData, sizeof(uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_KHR_create_renderpass2
+VkResult VkEncoder::vkCreateRenderPass2KHR(
+    VkDevice device,
+    const VkRenderPassCreateInfo2KHR* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkRenderPass* pRenderPass)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkRenderPassCreateInfo2KHR* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkRenderPassCreateInfo2KHR*)pool->alloc(sizeof(const VkRenderPassCreateInfo2KHR));
+        deepcopy_VkRenderPassCreateInfo2KHR(pool, pCreateInfo, (VkRenderPassCreateInfo2KHR*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1060;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1060, 1);
+        countingStream->write((uint64_t*)&cgen_var_1060, 1 * 8);
+        marshal_VkRenderPassCreateInfo2KHR(countingStream, (VkRenderPassCreateInfo2KHR*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1061 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1061);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1062;
+        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1062, 1);
+        countingStream->write((uint64_t*)&cgen_var_1062, 8);
+    }
+    uint32_t packetSize_vkCreateRenderPass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateRenderPass2KHR = OP_vkCreateRenderPass2KHR;
+    stream->write(&opcode_vkCreateRenderPass2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateRenderPass2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1063;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1063, 1);
+    stream->write((uint64_t*)&cgen_var_1063, 1 * 8);
+    marshal_VkRenderPassCreateInfo2KHR(stream, (VkRenderPassCreateInfo2KHR*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1064 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1064);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1065;
+    stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1065, 1);
+    stream->write((uint64_t*)&cgen_var_1065, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_1066;
+    stream->read((uint64_t*)&cgen_var_1066, 8);
+    stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_1066, (VkRenderPass*)pRenderPass, 1);
+    VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateRenderPass2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateRenderPass2KHR_VkResult_return;
+}
+
+void VkEncoder::vkCmdBeginRenderPass2KHR(
+    VkCommandBuffer commandBuffer,
+    const VkRenderPassBeginInfo* pRenderPassBegin,
+    const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkRenderPassBeginInfo* local_pRenderPassBegin;
+    VkSubpassBeginInfoKHR* local_pSubpassBeginInfo;
+    local_commandBuffer = commandBuffer;
+    local_pRenderPassBegin = nullptr;
+    if (pRenderPassBegin)
+    {
+        local_pRenderPassBegin = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
+        deepcopy_VkRenderPassBeginInfo(pool, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+    }
+    local_pSubpassBeginInfo = nullptr;
+    if (pSubpassBeginInfo)
+    {
+        local_pSubpassBeginInfo = (VkSubpassBeginInfoKHR*)pool->alloc(sizeof(const VkSubpassBeginInfoKHR));
+        deepcopy_VkSubpassBeginInfoKHR(pool, pSubpassBeginInfo, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1067;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1067, 1);
+        countingStream->write((uint64_t*)&cgen_var_1067, 1 * 8);
+        marshal_VkRenderPassBeginInfo(countingStream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+        marshal_VkSubpassBeginInfoKHR(countingStream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+    }
+    uint32_t packetSize_vkCmdBeginRenderPass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdBeginRenderPass2KHR = OP_vkCmdBeginRenderPass2KHR;
+    stream->write(&opcode_vkCmdBeginRenderPass2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdBeginRenderPass2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1068;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1068, 1);
+    stream->write((uint64_t*)&cgen_var_1068, 1 * 8);
+    marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+    marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+}
+
+void VkEncoder::vkCmdNextSubpass2KHR(
+    VkCommandBuffer commandBuffer,
+    const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+    const VkSubpassEndInfoKHR* pSubpassEndInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkSubpassBeginInfoKHR* local_pSubpassBeginInfo;
+    VkSubpassEndInfoKHR* local_pSubpassEndInfo;
+    local_commandBuffer = commandBuffer;
+    local_pSubpassBeginInfo = nullptr;
+    if (pSubpassBeginInfo)
+    {
+        local_pSubpassBeginInfo = (VkSubpassBeginInfoKHR*)pool->alloc(sizeof(const VkSubpassBeginInfoKHR));
+        deepcopy_VkSubpassBeginInfoKHR(pool, pSubpassBeginInfo, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+    }
+    local_pSubpassEndInfo = nullptr;
+    if (pSubpassEndInfo)
+    {
+        local_pSubpassEndInfo = (VkSubpassEndInfoKHR*)pool->alloc(sizeof(const VkSubpassEndInfoKHR));
+        deepcopy_VkSubpassEndInfoKHR(pool, pSubpassEndInfo, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1069;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1069, 1);
+        countingStream->write((uint64_t*)&cgen_var_1069, 1 * 8);
+        marshal_VkSubpassBeginInfoKHR(countingStream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+        marshal_VkSubpassEndInfoKHR(countingStream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+    }
+    uint32_t packetSize_vkCmdNextSubpass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdNextSubpass2KHR = OP_vkCmdNextSubpass2KHR;
+    stream->write(&opcode_vkCmdNextSubpass2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdNextSubpass2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1070;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1070, 1);
+    stream->write((uint64_t*)&cgen_var_1070, 1 * 8);
+    marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+    marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+}
+
+void VkEncoder::vkCmdEndRenderPass2KHR(
+    VkCommandBuffer commandBuffer,
+    const VkSubpassEndInfoKHR* pSubpassEndInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkSubpassEndInfoKHR* local_pSubpassEndInfo;
+    local_commandBuffer = commandBuffer;
+    local_pSubpassEndInfo = nullptr;
+    if (pSubpassEndInfo)
+    {
+        local_pSubpassEndInfo = (VkSubpassEndInfoKHR*)pool->alloc(sizeof(const VkSubpassEndInfoKHR));
+        deepcopy_VkSubpassEndInfoKHR(pool, pSubpassEndInfo, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1071;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1071, 1);
+        countingStream->write((uint64_t*)&cgen_var_1071, 1 * 8);
+        marshal_VkSubpassEndInfoKHR(countingStream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+    }
+    uint32_t packetSize_vkCmdEndRenderPass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdEndRenderPass2KHR = OP_vkCmdEndRenderPass2KHR;
+    stream->write(&opcode_vkCmdEndRenderPass2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdEndRenderPass2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1072;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1072, 1);
+    stream->write((uint64_t*)&cgen_var_1072, 1 * 8);
+    marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+}
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+VkResult VkEncoder::vkGetSwapchainStatusKHR(
+    VkDevice device,
+    VkSwapchainKHR swapchain)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSwapchainKHR local_swapchain;
+    local_device = device;
+    local_swapchain = swapchain;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1073;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1073, 1);
+        countingStream->write((uint64_t*)&cgen_var_1073, 1 * 8);
+        uint64_t cgen_var_1074;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1074, 1);
+        countingStream->write((uint64_t*)&cgen_var_1074, 1 * 8);
+    }
+    uint32_t packetSize_vkGetSwapchainStatusKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetSwapchainStatusKHR = OP_vkGetSwapchainStatusKHR;
+    stream->write(&opcode_vkGetSwapchainStatusKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetSwapchainStatusKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1075;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1075, 1);
+    stream->write((uint64_t*)&cgen_var_1075, 1 * 8);
+    uint64_t cgen_var_1076;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1076, 1);
+    stream->write((uint64_t*)&cgen_var_1076, 1 * 8);
+    VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetSwapchainStatusKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetSwapchainStatusKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+void VkEncoder::vkGetPhysicalDeviceExternalFencePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+    VkExternalFenceProperties* pExternalFenceProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceExternalFenceInfo* local_pExternalFenceInfo;
+    local_physicalDevice = physicalDevice;
+    local_pExternalFenceInfo = nullptr;
+    if (pExternalFenceInfo)
+    {
+        local_pExternalFenceInfo = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalFenceInfo));
+        deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, pExternalFenceInfo, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1077;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1077, 1);
+        countingStream->write((uint64_t*)&cgen_var_1077, 1 * 8);
+        marshal_VkPhysicalDeviceExternalFenceInfo(countingStream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+        marshal_VkExternalFenceProperties(countingStream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR = OP_vkGetPhysicalDeviceExternalFencePropertiesKHR;
+    stream->write(&opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1078;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1078, 1);
+    stream->write((uint64_t*)&cgen_var_1078, 1 * 8);
+    marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+    marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+    unmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+}
+
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+VkResult VkEncoder::vkImportFenceWin32HandleKHR(
+    VkDevice device,
+    const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImportFenceWin32HandleInfoKHR* local_pImportFenceWin32HandleInfo;
+    local_device = device;
+    local_pImportFenceWin32HandleInfo = nullptr;
+    if (pImportFenceWin32HandleInfo)
+    {
+        local_pImportFenceWin32HandleInfo = (VkImportFenceWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportFenceWin32HandleInfoKHR));
+        deepcopy_VkImportFenceWin32HandleInfoKHR(pool, pImportFenceWin32HandleInfo, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1079;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1079, 1);
+        countingStream->write((uint64_t*)&cgen_var_1079, 1 * 8);
+        marshal_VkImportFenceWin32HandleInfoKHR(countingStream, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
+    }
+    uint32_t packetSize_vkImportFenceWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkImportFenceWin32HandleKHR = OP_vkImportFenceWin32HandleKHR;
+    stream->write(&opcode_vkImportFenceWin32HandleKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkImportFenceWin32HandleKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1080;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1080, 1);
+    stream->write((uint64_t*)&cgen_var_1080, 1 * 8);
+    marshal_VkImportFenceWin32HandleInfoKHR(stream, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
+    VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkImportFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkImportFenceWin32HandleKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetFenceWin32HandleKHR(
+    VkDevice device,
+    const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+    HANDLE* pHandle)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkFenceGetWin32HandleInfoKHR* local_pGetWin32HandleInfo;
+    local_device = device;
+    local_pGetWin32HandleInfo = nullptr;
+    if (pGetWin32HandleInfo)
+    {
+        local_pGetWin32HandleInfo = (VkFenceGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkFenceGetWin32HandleInfoKHR));
+        deepcopy_VkFenceGetWin32HandleInfoKHR(pool, pGetWin32HandleInfo, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1081;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1081, 1);
+        countingStream->write((uint64_t*)&cgen_var_1081, 1 * 8);
+        marshal_VkFenceGetWin32HandleInfoKHR(countingStream, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+        countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
+    }
+    uint32_t packetSize_vkGetFenceWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetFenceWin32HandleKHR = OP_vkGetFenceWin32HandleKHR;
+    stream->write(&opcode_vkGetFenceWin32HandleKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetFenceWin32HandleKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1082;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1082, 1);
+    stream->write((uint64_t*)&cgen_var_1082, 1 * 8);
+    marshal_VkFenceGetWin32HandleInfoKHR(stream, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+    stream->write((HANDLE*)pHandle, sizeof(HANDLE));
+    stream->read((HANDLE*)pHandle, sizeof(HANDLE));
+    VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetFenceWin32HandleKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+VkResult VkEncoder::vkImportFenceFdKHR(
+    VkDevice device,
+    const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImportFenceFdInfoKHR* local_pImportFenceFdInfo;
+    local_device = device;
+    local_pImportFenceFdInfo = nullptr;
+    if (pImportFenceFdInfo)
+    {
+        local_pImportFenceFdInfo = (VkImportFenceFdInfoKHR*)pool->alloc(sizeof(const VkImportFenceFdInfoKHR));
+        deepcopy_VkImportFenceFdInfoKHR(pool, pImportFenceFdInfo, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1083;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1083, 1);
+        countingStream->write((uint64_t*)&cgen_var_1083, 1 * 8);
+        marshal_VkImportFenceFdInfoKHR(countingStream, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
+    }
+    uint32_t packetSize_vkImportFenceFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkImportFenceFdKHR = OP_vkImportFenceFdKHR;
+    stream->write(&opcode_vkImportFenceFdKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkImportFenceFdKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1084;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1084, 1);
+    stream->write((uint64_t*)&cgen_var_1084, 1 * 8);
+    marshal_VkImportFenceFdInfoKHR(stream, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
+    VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkImportFenceFdKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkImportFenceFdKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetFenceFdKHR(
+    VkDevice device,
+    const VkFenceGetFdInfoKHR* pGetFdInfo,
+    int* pFd)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkFenceGetFdInfoKHR* local_pGetFdInfo;
+    local_device = device;
+    local_pGetFdInfo = nullptr;
+    if (pGetFdInfo)
+    {
+        local_pGetFdInfo = (VkFenceGetFdInfoKHR*)pool->alloc(sizeof(const VkFenceGetFdInfoKHR));
+        deepcopy_VkFenceGetFdInfoKHR(pool, pGetFdInfo, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1085;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1085, 1);
+        countingStream->write((uint64_t*)&cgen_var_1085, 1 * 8);
+        marshal_VkFenceGetFdInfoKHR(countingStream, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
+        countingStream->write((int*)pFd, sizeof(int));
+    }
+    uint32_t packetSize_vkGetFenceFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetFenceFdKHR = OP_vkGetFenceFdKHR;
+    stream->write(&opcode_vkGetFenceFdKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetFenceFdKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1086;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1086, 1);
+    stream->write((uint64_t*)&cgen_var_1086, 1 * 8);
+    marshal_VkFenceGetFdInfoKHR(stream, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
+    stream->write((int*)pFd, sizeof(int));
+    stream->read((int*)pFd, sizeof(int));
+    VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetFenceFdKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetFenceFdKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+    VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceSurfaceInfo2KHR* local_pSurfaceInfo;
+    local_physicalDevice = physicalDevice;
+    local_pSurfaceInfo = nullptr;
+    if (pSurfaceInfo)
+    {
+        local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
+        deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1087;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1087, 1);
+        countingStream->write((uint64_t*)&cgen_var_1087, 1 * 8);
+        marshal_VkPhysicalDeviceSurfaceInfo2KHR(countingStream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+        marshal_VkSurfaceCapabilities2KHR(countingStream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR = OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1088;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1088, 1);
+    stream->write((uint64_t*)&cgen_var_1088, 1 * 8);
+    marshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+    marshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
+    unmarshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+    uint32_t* pSurfaceFormatCount,
+    VkSurfaceFormat2KHR* pSurfaceFormats)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkPhysicalDeviceSurfaceInfo2KHR* local_pSurfaceInfo;
+    local_physicalDevice = physicalDevice;
+    local_pSurfaceInfo = nullptr;
+    if (pSurfaceInfo)
+    {
+        local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
+        deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1089;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1089, 1);
+        countingStream->write((uint64_t*)&cgen_var_1089, 1 * 8);
+        marshal_VkPhysicalDeviceSurfaceInfo2KHR(countingStream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1090 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+        countingStream->putBe64(cgen_var_1090);
+        if (pSurfaceFormatCount)
+        {
+            countingStream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1091 = (uint64_t)(uintptr_t)pSurfaceFormats;
+        countingStream->putBe64(cgen_var_1091);
+        if (pSurfaceFormats)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+            {
+                marshal_VkSurfaceFormat2KHR(countingStream, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceSurfaceFormats2KHR = OP_vkGetPhysicalDeviceSurfaceFormats2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1092;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1092, 1);
+    stream->write((uint64_t*)&cgen_var_1092, 1 * 8);
+    marshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1093 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+    stream->putBe64(cgen_var_1093);
+    if (pSurfaceFormatCount)
+    {
+        stream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1094 = (uint64_t)(uintptr_t)pSurfaceFormats;
+    stream->putBe64(cgen_var_1094);
+    if (pSurfaceFormats)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+        {
+            marshal_VkSurfaceFormat2KHR(stream, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pSurfaceFormatCount;
+    check_pSurfaceFormatCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pSurfaceFormatCount)
+    {
+        if (!(check_pSurfaceFormatCount))
+        {
+            fprintf(stderr, "fatal: pSurfaceFormatCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkSurfaceFormat2KHR* check_pSurfaceFormats;
+    check_pSurfaceFormats = (VkSurfaceFormat2KHR*)(uintptr_t)stream->getBe64();
+    if (pSurfaceFormats)
+    {
+        if (!(check_pSurfaceFormats))
+        {
+            fprintf(stderr, "fatal: pSurfaceFormats inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+        {
+            unmarshal_VkSurfaceFormat2KHR(stream, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
+        }
+    }
+    VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pPropertyCount,
+    VkDisplayProperties2KHR* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1097;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1097, 1);
+        countingStream->write((uint64_t*)&cgen_var_1097, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1098 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_1098);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1099 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_1099);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkDisplayProperties2KHR(countingStream, (VkDisplayProperties2KHR*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceDisplayProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceDisplayProperties2KHR = OP_vkGetPhysicalDeviceDisplayProperties2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1100;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1100, 1);
+    stream->write((uint64_t*)&cgen_var_1100, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1101 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_1101);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1102 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_1102);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkDisplayProperties2KHR(stream, (VkDisplayProperties2KHR*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkDisplayProperties2KHR* check_pProperties;
+    check_pProperties = (VkDisplayProperties2KHR*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkDisplayProperties2KHR(stream, (VkDisplayProperties2KHR*)(pProperties + i));
+        }
+    }
+    VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    uint32_t* pPropertyCount,
+    VkDisplayPlaneProperties2KHR* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1105;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1105, 1);
+        countingStream->write((uint64_t*)&cgen_var_1105, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1106 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_1106);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1107 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_1107);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkDisplayPlaneProperties2KHR(countingStream, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
+    stream->write(&opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1108;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1108, 1);
+    stream->write((uint64_t*)&cgen_var_1108, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1109 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_1109);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1110 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_1110);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkDisplayPlaneProperties2KHR(stream, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkDisplayPlaneProperties2KHR* check_pProperties;
+    check_pProperties = (VkDisplayPlaneProperties2KHR*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkDisplayPlaneProperties2KHR(stream, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
+        }
+    }
+    VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDisplayModeProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+    VkDisplayKHR display,
+    uint32_t* pPropertyCount,
+    VkDisplayModeProperties2KHR* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkDisplayKHR local_display;
+    local_physicalDevice = physicalDevice;
+    local_display = display;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1113;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1113, 1);
+        countingStream->write((uint64_t*)&cgen_var_1113, 1 * 8);
+        uint64_t cgen_var_1114;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1114, 1);
+        countingStream->write((uint64_t*)&cgen_var_1114, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1115 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_1115);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1116 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_1116);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkDisplayModeProperties2KHR(countingStream, (VkDisplayModeProperties2KHR*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetDisplayModeProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDisplayModeProperties2KHR = OP_vkGetDisplayModeProperties2KHR;
+    stream->write(&opcode_vkGetDisplayModeProperties2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDisplayModeProperties2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1117;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1117, 1);
+    stream->write((uint64_t*)&cgen_var_1117, 1 * 8);
+    uint64_t cgen_var_1118;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1118, 1);
+    stream->write((uint64_t*)&cgen_var_1118, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1119 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_1119);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1120 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_1120);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkDisplayModeProperties2KHR(stream, (VkDisplayModeProperties2KHR*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkDisplayModeProperties2KHR* check_pProperties;
+    check_pProperties = (VkDisplayModeProperties2KHR*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkDisplayModeProperties2KHR(stream, (VkDisplayModeProperties2KHR*)(pProperties + i));
+        }
+    }
+    VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetDisplayModeProperties2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetDisplayModeProperties2KHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDisplayPlaneCapabilities2KHR(
+    VkPhysicalDevice physicalDevice,
+    const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+    VkDisplayPlaneCapabilities2KHR* pCapabilities)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkDisplayPlaneInfo2KHR* local_pDisplayPlaneInfo;
+    local_physicalDevice = physicalDevice;
+    local_pDisplayPlaneInfo = nullptr;
+    if (pDisplayPlaneInfo)
+    {
+        local_pDisplayPlaneInfo = (VkDisplayPlaneInfo2KHR*)pool->alloc(sizeof(const VkDisplayPlaneInfo2KHR));
+        deepcopy_VkDisplayPlaneInfo2KHR(pool, pDisplayPlaneInfo, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1123;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1123, 1);
+        countingStream->write((uint64_t*)&cgen_var_1123, 1 * 8);
+        marshal_VkDisplayPlaneInfo2KHR(countingStream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
+        marshal_VkDisplayPlaneCapabilities2KHR(countingStream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
+    }
+    uint32_t packetSize_vkGetDisplayPlaneCapabilities2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDisplayPlaneCapabilities2KHR = OP_vkGetDisplayPlaneCapabilities2KHR;
+    stream->write(&opcode_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1124;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1124, 1);
+    stream->write((uint64_t*)&cgen_var_1124, 1 * 8);
+    marshal_VkDisplayPlaneInfo2KHR(stream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
+    marshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
+    unmarshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
+    VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkGetDisplayPlaneCapabilities2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetDisplayPlaneCapabilities2KHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+void VkEncoder::vkGetImageMemoryRequirements2KHR(
+    VkDevice device,
+    const VkImageMemoryRequirementsInfo2* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImageMemoryRequirementsInfo2* local_pInfo;
+    local_device = device;
+    local_pInfo = nullptr;
+    if (pInfo)
+    {
+        local_pInfo = (VkImageMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageMemoryRequirementsInfo2));
+        deepcopy_VkImageMemoryRequirementsInfo2(pool, pInfo, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1125;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1125, 1);
+        countingStream->write((uint64_t*)&cgen_var_1125, 1 * 8);
+        marshal_VkImageMemoryRequirementsInfo2(countingStream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+        marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
+    }
+    uint32_t packetSize_vkGetImageMemoryRequirements2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetImageMemoryRequirements2KHR = OP_vkGetImageMemoryRequirements2KHR;
+    stream->write(&opcode_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1126;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1126, 1);
+    stream->write((uint64_t*)&cgen_var_1126, 1 * 8);
+    marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+    marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+    unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetBufferMemoryRequirements2KHR(
+    VkDevice device,
+    const VkBufferMemoryRequirementsInfo2* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkBufferMemoryRequirementsInfo2* local_pInfo;
+    local_device = device;
+    local_pInfo = nullptr;
+    if (pInfo)
+    {
+        local_pInfo = (VkBufferMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkBufferMemoryRequirementsInfo2));
+        deepcopy_VkBufferMemoryRequirementsInfo2(pool, pInfo, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1127;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1127, 1);
+        countingStream->write((uint64_t*)&cgen_var_1127, 1 * 8);
+        marshal_VkBufferMemoryRequirementsInfo2(countingStream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+        marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
+    }
+    uint32_t packetSize_vkGetBufferMemoryRequirements2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetBufferMemoryRequirements2KHR = OP_vkGetBufferMemoryRequirements2KHR;
+    stream->write(&opcode_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1128;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1128, 1);
+    stream->write((uint64_t*)&cgen_var_1128, 1 * 8);
+    marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+    marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+    unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetImageSparseMemoryRequirements2KHR(
+    VkDevice device,
+    const VkImageSparseMemoryRequirementsInfo2* pInfo,
+    uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImageSparseMemoryRequirementsInfo2* local_pInfo;
+    local_device = device;
+    local_pInfo = nullptr;
+    if (pInfo)
+    {
+        local_pInfo = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageSparseMemoryRequirementsInfo2));
+        deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, pInfo, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1129;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1129, 1);
+        countingStream->write((uint64_t*)&cgen_var_1129, 1 * 8);
+        marshal_VkImageSparseMemoryRequirementsInfo2(countingStream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1130 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+        countingStream->putBe64(cgen_var_1130);
+        if (pSparseMemoryRequirementCount)
+        {
+            countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1131 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+        countingStream->putBe64(cgen_var_1131);
+        if (pSparseMemoryRequirements)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+            {
+                marshal_VkSparseImageMemoryRequirements2(countingStream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetImageSparseMemoryRequirements2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetImageSparseMemoryRequirements2KHR = OP_vkGetImageSparseMemoryRequirements2KHR;
+    stream->write(&opcode_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1132;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1132, 1);
+    stream->write((uint64_t*)&cgen_var_1132, 1 * 8);
+    marshal_VkImageSparseMemoryRequirementsInfo2(stream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1133 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+    stream->putBe64(cgen_var_1133);
+    if (pSparseMemoryRequirementCount)
+    {
+        stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1134 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+    stream->putBe64(cgen_var_1134);
+    if (pSparseMemoryRequirements)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+        {
+            marshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pSparseMemoryRequirementCount;
+    check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pSparseMemoryRequirementCount)
+    {
+        if (!(check_pSparseMemoryRequirementCount))
+        {
+            fprintf(stderr, "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkSparseImageMemoryRequirements2* check_pSparseMemoryRequirements;
+    check_pSparseMemoryRequirements = (VkSparseImageMemoryRequirements2*)(uintptr_t)stream->getBe64();
+    if (pSparseMemoryRequirements)
+    {
+        if (!(check_pSparseMemoryRequirements))
+        {
+            fprintf(stderr, "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+        {
+            unmarshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+VkResult VkEncoder::vkCreateSamplerYcbcrConversionKHR(
+    VkDevice device,
+    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSamplerYcbcrConversionCreateInfo* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(sizeof(const VkSamplerYcbcrConversionCreateInfo));
+        deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, pCreateInfo, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1137;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1137, 1);
+        countingStream->write((uint64_t*)&cgen_var_1137, 1 * 8);
+        marshal_VkSamplerYcbcrConversionCreateInfo(countingStream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1138 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1138);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1139;
+        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1139, 1);
+        countingStream->write((uint64_t*)&cgen_var_1139, 8);
+    }
+    uint32_t packetSize_vkCreateSamplerYcbcrConversionKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateSamplerYcbcrConversionKHR = OP_vkCreateSamplerYcbcrConversionKHR;
+    stream->write(&opcode_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1140;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1140, 1);
+    stream->write((uint64_t*)&cgen_var_1140, 1 * 8);
+    marshal_VkSamplerYcbcrConversionCreateInfo(stream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1141 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1141);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1142;
+    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1142, 1);
+    stream->write((uint64_t*)&cgen_var_1142, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_1143;
+    stream->read((uint64_t*)&cgen_var_1143, 8);
+    stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_1143, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
+    VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateSamplerYcbcrConversionKHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
+}
+
+void VkEncoder::vkDestroySamplerYcbcrConversionKHR(
+    VkDevice device,
+    VkSamplerYcbcrConversion ycbcrConversion,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSamplerYcbcrConversion local_ycbcrConversion;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_ycbcrConversion = ycbcrConversion;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1144;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1144, 1);
+        countingStream->write((uint64_t*)&cgen_var_1144, 1 * 8);
+        uint64_t cgen_var_1145;
+        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1145, 1);
+        countingStream->write((uint64_t*)&cgen_var_1145, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1146 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1146);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroySamplerYcbcrConversionKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroySamplerYcbcrConversionKHR = OP_vkDestroySamplerYcbcrConversionKHR;
+    stream->write(&opcode_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1147;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1147, 1);
+    stream->write((uint64_t*)&cgen_var_1147, 1 * 8);
+    uint64_t cgen_var_1148;
+    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1148, 1);
+    stream->write((uint64_t*)&cgen_var_1148, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1149 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1149);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+}
+
+#endif
+#ifdef VK_KHR_bind_memory2
+VkResult VkEncoder::vkBindBufferMemory2KHR(
+    VkDevice device,
+    uint32_t bindInfoCount,
+    const VkBindBufferMemoryInfo* pBindInfos)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_bindInfoCount;
+    VkBindBufferMemoryInfo* local_pBindInfos;
+    local_device = device;
+    local_bindInfoCount = bindInfoCount;
+    local_pBindInfos = nullptr;
+    if (pBindInfos)
+    {
+        local_pBindInfos = (VkBindBufferMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            deepcopy_VkBindBufferMemoryInfo(pool, pBindInfos + i, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1150;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1150, 1);
+        countingStream->write((uint64_t*)&cgen_var_1150, 1 * 8);
+        countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            marshal_VkBindBufferMemoryInfo(countingStream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+        }
+    }
+    uint32_t packetSize_vkBindBufferMemory2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkBindBufferMemory2KHR = OP_vkBindBufferMemory2KHR;
+    stream->write(&opcode_vkBindBufferMemory2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkBindBufferMemory2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1151;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1151, 1);
+    stream->write((uint64_t*)&cgen_var_1151, 1 * 8);
+    stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+    {
+        marshal_VkBindBufferMemoryInfo(stream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+    }
+    VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkBindBufferMemory2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkBindBufferMemory2KHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkBindImageMemory2KHR(
+    VkDevice device,
+    uint32_t bindInfoCount,
+    const VkBindImageMemoryInfo* pBindInfos)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_bindInfoCount;
+    VkBindImageMemoryInfo* local_pBindInfos;
+    local_device = device;
+    local_bindInfoCount = bindInfoCount;
+    local_pBindInfos = nullptr;
+    if (pBindInfos)
+    {
+        local_pBindInfos = (VkBindImageMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindImageMemoryInfo));
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            deepcopy_VkBindImageMemoryInfo(pool, pBindInfos + i, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1152;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1152, 1);
+        countingStream->write((uint64_t*)&cgen_var_1152, 1 * 8);
+        countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            marshal_VkBindImageMemoryInfo(countingStream, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+        }
+    }
+    uint32_t packetSize_vkBindImageMemory2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkBindImageMemory2KHR = OP_vkBindImageMemory2KHR;
+    stream->write(&opcode_vkBindImageMemory2KHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkBindImageMemory2KHR, sizeof(uint32_t));
+    uint64_t cgen_var_1153;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1153, 1);
+    stream->write((uint64_t*)&cgen_var_1153, 1 * 8);
+    stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+    {
+        marshal_VkBindImageMemoryInfo(stream, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+    }
+    VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
+    stream->read(&vkBindImageMemory2KHR_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkBindImageMemory2KHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_maintenance3
+void VkEncoder::vkGetDescriptorSetLayoutSupportKHR(
+    VkDevice device,
+    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    VkDescriptorSetLayoutSupport* pSupport)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDescriptorSetLayoutCreateInfo* local_pCreateInfo;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
+        deepcopy_VkDescriptorSetLayoutCreateInfo(pool, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1154;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1154, 1);
+        countingStream->write((uint64_t*)&cgen_var_1154, 1 * 8);
+        marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+        marshal_VkDescriptorSetLayoutSupport(countingStream, (VkDescriptorSetLayoutSupport*)(pSupport));
+    }
+    uint32_t packetSize_vkGetDescriptorSetLayoutSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetDescriptorSetLayoutSupportKHR = OP_vkGetDescriptorSetLayoutSupportKHR;
+    stream->write(&opcode_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1155;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1155, 1);
+    stream->write((uint64_t*)&cgen_var_1155, 1 * 8);
+    marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+    marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
+    unmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
+}
+
+#endif
+#ifdef VK_KHR_draw_indirect_count
+void VkEncoder::vkCmdDrawIndirectCountKHR(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    VkBuffer countBuffer,
+    VkDeviceSize countBufferOffset,
+    uint32_t maxDrawCount,
+    uint32_t stride)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_buffer;
+    VkDeviceSize local_offset;
+    VkBuffer local_countBuffer;
+    VkDeviceSize local_countBufferOffset;
+    uint32_t local_maxDrawCount;
+    uint32_t local_stride;
+    local_commandBuffer = commandBuffer;
+    local_buffer = buffer;
+    local_offset = offset;
+    local_countBuffer = countBuffer;
+    local_countBufferOffset = countBufferOffset;
+    local_maxDrawCount = maxDrawCount;
+    local_stride = stride;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1156;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1156, 1);
+        countingStream->write((uint64_t*)&cgen_var_1156, 1 * 8);
+        uint64_t cgen_var_1157;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1157, 1);
+        countingStream->write((uint64_t*)&cgen_var_1157, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+        uint64_t cgen_var_1158;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1158, 1);
+        countingStream->write((uint64_t*)&cgen_var_1158, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+        countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDrawIndirectCountKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDrawIndirectCountKHR = OP_vkCmdDrawIndirectCountKHR;
+    stream->write(&opcode_vkCmdDrawIndirectCountKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDrawIndirectCountKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1159;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1159, 1);
+    stream->write((uint64_t*)&cgen_var_1159, 1 * 8);
+    uint64_t cgen_var_1160;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1160, 1);
+    stream->write((uint64_t*)&cgen_var_1160, 1 * 8);
+    stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+    uint64_t cgen_var_1161;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1161, 1);
+    stream->write((uint64_t*)&cgen_var_1161, 1 * 8);
+    stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+    stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDrawIndexedIndirectCountKHR(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    VkBuffer countBuffer,
+    VkDeviceSize countBufferOffset,
+    uint32_t maxDrawCount,
+    uint32_t stride)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_buffer;
+    VkDeviceSize local_offset;
+    VkBuffer local_countBuffer;
+    VkDeviceSize local_countBufferOffset;
+    uint32_t local_maxDrawCount;
+    uint32_t local_stride;
+    local_commandBuffer = commandBuffer;
+    local_buffer = buffer;
+    local_offset = offset;
+    local_countBuffer = countBuffer;
+    local_countBufferOffset = countBufferOffset;
+    local_maxDrawCount = maxDrawCount;
+    local_stride = stride;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1162;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1162, 1);
+        countingStream->write((uint64_t*)&cgen_var_1162, 1 * 8);
+        uint64_t cgen_var_1163;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1163, 1);
+        countingStream->write((uint64_t*)&cgen_var_1163, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+        uint64_t cgen_var_1164;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1164, 1);
+        countingStream->write((uint64_t*)&cgen_var_1164, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+        countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDrawIndexedIndirectCountKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDrawIndexedIndirectCountKHR = OP_vkCmdDrawIndexedIndirectCountKHR;
+    stream->write(&opcode_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t));
+    uint64_t cgen_var_1165;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1165, 1);
+    stream->write((uint64_t*)&cgen_var_1165, 1 * 8);
+    uint64_t cgen_var_1166;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1166, 1);
+    stream->write((uint64_t*)&cgen_var_1166, 1 * 8);
+    stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+    uint64_t cgen_var_1167;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1167, 1);
+    stream->write((uint64_t*)&cgen_var_1167, 1 * 8);
+    stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+    stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID(
+    VkDevice device,
+    VkFormat format,
+    VkImageUsageFlags imageUsage,
+    int* grallocUsage)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkFormat local_format;
+    VkImageUsageFlags local_imageUsage;
+    local_device = device;
+    local_format = format;
+    local_imageUsage = imageUsage;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1168;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1168, 1);
+        countingStream->write((uint64_t*)&cgen_var_1168, 1 * 8);
+        countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+        countingStream->write((VkImageUsageFlags*)&local_imageUsage, sizeof(VkImageUsageFlags));
+        countingStream->write((int*)grallocUsage, sizeof(int));
+    }
+    uint32_t packetSize_vkGetSwapchainGrallocUsageANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetSwapchainGrallocUsageANDROID = OP_vkGetSwapchainGrallocUsageANDROID;
+    stream->write(&opcode_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
+    uint64_t cgen_var_1169;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1169, 1);
+    stream->write((uint64_t*)&cgen_var_1169, 1 * 8);
+    stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+    stream->write((VkImageUsageFlags*)&local_imageUsage, sizeof(VkImageUsageFlags));
+    stream->write((int*)grallocUsage, sizeof(int));
+    stream->read((int*)grallocUsage, sizeof(int));
+    VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
+    stream->read(&vkGetSwapchainGrallocUsageANDROID_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
+}
+
+VkResult VkEncoder::vkAcquireImageANDROID(
+    VkDevice device,
+    VkImage image,
+    int nativeFenceFd,
+    VkSemaphore semaphore,
+    VkFence fence)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkImage local_image;
+    int local_nativeFenceFd;
+    VkSemaphore local_semaphore;
+    VkFence local_fence;
+    local_device = device;
+    local_image = image;
+    local_nativeFenceFd = nativeFenceFd;
+    local_semaphore = semaphore;
+    local_fence = fence;
+    goldfish_unwrap_vkAcquireImageANDROID_nativeFenceFd(nativeFenceFd, &local_nativeFenceFd);
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1170;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1170, 1);
+        countingStream->write((uint64_t*)&cgen_var_1170, 1 * 8);
+        uint64_t cgen_var_1171;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1171, 1);
+        countingStream->write((uint64_t*)&cgen_var_1171, 1 * 8);
+        countingStream->write((int*)&local_nativeFenceFd, sizeof(int));
+        uint64_t cgen_var_1172;
+        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1172, 1);
+        countingStream->write((uint64_t*)&cgen_var_1172, 1 * 8);
+        uint64_t cgen_var_1173;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1173, 1);
+        countingStream->write((uint64_t*)&cgen_var_1173, 1 * 8);
+    }
+    uint32_t packetSize_vkAcquireImageANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkAcquireImageANDROID = OP_vkAcquireImageANDROID;
+    stream->write(&opcode_vkAcquireImageANDROID, sizeof(uint32_t));
+    stream->write(&packetSize_vkAcquireImageANDROID, sizeof(uint32_t));
+    uint64_t cgen_var_1174;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1174, 1);
+    stream->write((uint64_t*)&cgen_var_1174, 1 * 8);
+    uint64_t cgen_var_1175;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1175, 1);
+    stream->write((uint64_t*)&cgen_var_1175, 1 * 8);
+    stream->write((int*)&local_nativeFenceFd, sizeof(int));
+    uint64_t cgen_var_1176;
+    stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1176, 1);
+    stream->write((uint64_t*)&cgen_var_1176, 1 * 8);
+    uint64_t cgen_var_1177;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1177, 1);
+    stream->write((uint64_t*)&cgen_var_1177, 1 * 8);
+    VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
+    stream->read(&vkAcquireImageANDROID_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkAcquireImageANDROID_VkResult_return;
+}
+
+VkResult VkEncoder::vkQueueSignalReleaseImageANDROID(
+    VkQueue queue,
+    uint32_t waitSemaphoreCount,
+    const VkSemaphore* pWaitSemaphores,
+    VkImage image,
+    int* pNativeFenceFd)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkQueue local_queue;
+    uint32_t local_waitSemaphoreCount;
+    VkSemaphore* local_pWaitSemaphores;
+    VkImage local_image;
+    local_queue = queue;
+    local_waitSemaphoreCount = waitSemaphoreCount;
+    local_pWaitSemaphores = nullptr;
+    if (pWaitSemaphores)
+    {
+        local_pWaitSemaphores = (VkSemaphore*)pool->dupArray(pWaitSemaphores, sizeof(const VkSemaphore));
+    }
+    local_image = image;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1178;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1178, 1);
+        countingStream->write((uint64_t*)&cgen_var_1178, 1 * 8);
+        countingStream->write((uint32_t*)&local_waitSemaphoreCount, sizeof(uint32_t));
+        uint64_t cgen_var_1179;
+        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, &cgen_var_1179, 1);
+        countingStream->write((uint64_t*)&cgen_var_1179, 8);
+        uint64_t cgen_var_1180;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1180, 1);
+        countingStream->write((uint64_t*)&cgen_var_1180, 1 * 8);
+        countingStream->write((int*)pNativeFenceFd, sizeof(int));
+    }
+    uint32_t packetSize_vkQueueSignalReleaseImageANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueSignalReleaseImageANDROID = OP_vkQueueSignalReleaseImageANDROID;
+    stream->write(&opcode_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
+    uint64_t cgen_var_1181;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1181, 1);
+    stream->write((uint64_t*)&cgen_var_1181, 1 * 8);
+    stream->write((uint32_t*)&local_waitSemaphoreCount, sizeof(uint32_t));
+    uint64_t cgen_var_1182;
+    stream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, &cgen_var_1182, 1);
+    stream->write((uint64_t*)&cgen_var_1182, 8);
+    uint64_t cgen_var_1183;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1183, 1);
+    stream->write((uint64_t*)&cgen_var_1183, 1 * 8);
+    stream->write((int*)pNativeFenceFd, sizeof(int));
+    stream->read((int*)pNativeFenceFd, sizeof(int));
+    VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
+    stream->read(&vkQueueSignalReleaseImageANDROID_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkQueueSignalReleaseImageANDROID_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_debug_report
+VkResult VkEncoder::vkCreateDebugReportCallbackEXT(
+    VkInstance instance,
+    const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDebugReportCallbackEXT* pCallback)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkDebugReportCallbackCreateInfoEXT* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDebugReportCallbackCreateInfoEXT*)pool->alloc(sizeof(const VkDebugReportCallbackCreateInfoEXT));
+        deepcopy_VkDebugReportCallbackCreateInfoEXT(pool, pCreateInfo, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1184;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1184, 1);
+        countingStream->write((uint64_t*)&cgen_var_1184, 1 * 8);
+        marshal_VkDebugReportCallbackCreateInfoEXT(countingStream, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1185 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1185);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1186;
+        countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1186, 1);
+        countingStream->write((uint64_t*)&cgen_var_1186, 8);
+    }
+    uint32_t packetSize_vkCreateDebugReportCallbackEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateDebugReportCallbackEXT = OP_vkCreateDebugReportCallbackEXT;
+    stream->write(&opcode_vkCreateDebugReportCallbackEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateDebugReportCallbackEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1187;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1187, 1);
+    stream->write((uint64_t*)&cgen_var_1187, 1 * 8);
+    marshal_VkDebugReportCallbackCreateInfoEXT(stream, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1188 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1188);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1189;
+    stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1189, 1);
+    stream->write((uint64_t*)&cgen_var_1189, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_1190;
+    stream->read((uint64_t*)&cgen_var_1190, 8);
+    stream->handleMapping()->mapHandles_u64_VkDebugReportCallbackEXT(&cgen_var_1190, (VkDebugReportCallbackEXT*)pCallback, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateDebugReportCallbackEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateDebugReportCallbackEXT_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDebugReportCallbackEXT(
+    VkInstance instance,
+    VkDebugReportCallbackEXT callback,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkDebugReportCallbackEXT local_callback;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_callback = callback;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1191;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1191, 1);
+        countingStream->write((uint64_t*)&cgen_var_1191, 1 * 8);
+        uint64_t cgen_var_1192;
+        countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1192, 1);
+        countingStream->write((uint64_t*)&cgen_var_1192, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1193 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1193);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyDebugReportCallbackEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyDebugReportCallbackEXT = OP_vkDestroyDebugReportCallbackEXT;
+    stream->write(&opcode_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1194;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1194, 1);
+    stream->write((uint64_t*)&cgen_var_1194, 1 * 8);
+    uint64_t cgen_var_1195;
+    stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1195, 1);
+    stream->write((uint64_t*)&cgen_var_1195, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1196 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1196);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkDebugReportCallbackEXT((VkDebugReportCallbackEXT*)&callback);
+}
+
+void VkEncoder::vkDebugReportMessageEXT(
+    VkInstance instance,
+    VkDebugReportFlagsEXT flags,
+    VkDebugReportObjectTypeEXT objectType,
+    uint64_t object,
+    size_t location,
+    int32_t messageCode,
+    const char* pLayerPrefix,
+    const char* pMessage)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkDebugReportFlagsEXT local_flags;
+    VkDebugReportObjectTypeEXT local_objectType;
+    uint64_t local_object;
+    size_t local_location;
+    int32_t local_messageCode;
+    char* local_pLayerPrefix;
+    char* local_pMessage;
+    local_instance = instance;
+    local_flags = flags;
+    local_objectType = objectType;
+    local_object = object;
+    local_location = location;
+    local_messageCode = messageCode;
+    local_pLayerPrefix = nullptr;
+    if (pLayerPrefix)
+    {
+        local_pLayerPrefix = pool->strDup(pLayerPrefix);
+    }
+    local_pMessage = nullptr;
+    if (pMessage)
+    {
+        local_pMessage = pool->strDup(pMessage);
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1197;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1197, 1);
+        countingStream->write((uint64_t*)&cgen_var_1197, 1 * 8);
+        countingStream->write((VkDebugReportFlagsEXT*)&local_flags, sizeof(VkDebugReportFlagsEXT));
+        countingStream->write((VkDebugReportObjectTypeEXT*)&local_objectType, sizeof(VkDebugReportObjectTypeEXT));
+        countingStream->write((uint64_t*)&local_object, sizeof(uint64_t));
+        uint64_t cgen_var_1198 = (uint64_t)local_location;
+        countingStream->putBe64(cgen_var_1198);
+        countingStream->write((int32_t*)&local_messageCode, sizeof(int32_t));
+        countingStream->putString(local_pLayerPrefix);
+        countingStream->putString(local_pMessage);
+    }
+    uint32_t packetSize_vkDebugReportMessageEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDebugReportMessageEXT = OP_vkDebugReportMessageEXT;
+    stream->write(&opcode_vkDebugReportMessageEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkDebugReportMessageEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1199;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1199, 1);
+    stream->write((uint64_t*)&cgen_var_1199, 1 * 8);
+    stream->write((VkDebugReportFlagsEXT*)&local_flags, sizeof(VkDebugReportFlagsEXT));
+    stream->write((VkDebugReportObjectTypeEXT*)&local_objectType, sizeof(VkDebugReportObjectTypeEXT));
+    stream->write((uint64_t*)&local_object, sizeof(uint64_t));
+    uint64_t cgen_var_1200 = (uint64_t)local_location;
+    stream->putBe64(cgen_var_1200);
+    stream->write((int32_t*)&local_messageCode, sizeof(int32_t));
+    stream->putString(local_pLayerPrefix);
+    stream->putString(local_pMessage);
+}
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+VkResult VkEncoder::vkDebugMarkerSetObjectTagEXT(
+    VkDevice device,
+    const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDebugMarkerObjectTagInfoEXT* local_pTagInfo;
+    local_device = device;
+    local_pTagInfo = nullptr;
+    if (pTagInfo)
+    {
+        local_pTagInfo = (VkDebugMarkerObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerObjectTagInfoEXT));
+        deepcopy_VkDebugMarkerObjectTagInfoEXT(pool, pTagInfo, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1201;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1201, 1);
+        countingStream->write((uint64_t*)&cgen_var_1201, 1 * 8);
+        marshal_VkDebugMarkerObjectTagInfoEXT(countingStream, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
+    }
+    uint32_t packetSize_vkDebugMarkerSetObjectTagEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDebugMarkerSetObjectTagEXT = OP_vkDebugMarkerSetObjectTagEXT;
+    stream->write(&opcode_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1202;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1202, 1);
+    stream->write((uint64_t*)&cgen_var_1202, 1 * 8);
+    marshal_VkDebugMarkerObjectTagInfoEXT(stream, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
+    VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkDebugMarkerSetObjectTagEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkDebugMarkerSetObjectTagEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkDebugMarkerSetObjectNameEXT(
+    VkDevice device,
+    const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDebugMarkerObjectNameInfoEXT* local_pNameInfo;
+    local_device = device;
+    local_pNameInfo = nullptr;
+    if (pNameInfo)
+    {
+        local_pNameInfo = (VkDebugMarkerObjectNameInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerObjectNameInfoEXT));
+        deepcopy_VkDebugMarkerObjectNameInfoEXT(pool, pNameInfo, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1203;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1203, 1);
+        countingStream->write((uint64_t*)&cgen_var_1203, 1 * 8);
+        marshal_VkDebugMarkerObjectNameInfoEXT(countingStream, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
+    }
+    uint32_t packetSize_vkDebugMarkerSetObjectNameEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDebugMarkerSetObjectNameEXT = OP_vkDebugMarkerSetObjectNameEXT;
+    stream->write(&opcode_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1204;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1204, 1);
+    stream->write((uint64_t*)&cgen_var_1204, 1 * 8);
+    marshal_VkDebugMarkerObjectNameInfoEXT(stream, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
+    VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkDebugMarkerSetObjectNameEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkDebugMarkerSetObjectNameEXT_VkResult_return;
+}
+
+void VkEncoder::vkCmdDebugMarkerBeginEXT(
+    VkCommandBuffer commandBuffer,
+    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkDebugMarkerMarkerInfoEXT* local_pMarkerInfo;
+    local_commandBuffer = commandBuffer;
+    local_pMarkerInfo = nullptr;
+    if (pMarkerInfo)
+    {
+        local_pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
+        deepcopy_VkDebugMarkerMarkerInfoEXT(pool, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1205;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1205, 1);
+        countingStream->write((uint64_t*)&cgen_var_1205, 1 * 8);
+        marshal_VkDebugMarkerMarkerInfoEXT(countingStream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+    }
+    uint32_t packetSize_vkCmdDebugMarkerBeginEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDebugMarkerBeginEXT = OP_vkCmdDebugMarkerBeginEXT;
+    stream->write(&opcode_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1206;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1206, 1);
+    stream->write((uint64_t*)&cgen_var_1206, 1 * 8);
+    marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+}
+
+void VkEncoder::vkCmdDebugMarkerEndEXT(
+    VkCommandBuffer commandBuffer)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    local_commandBuffer = commandBuffer;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1207;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1207, 1);
+        countingStream->write((uint64_t*)&cgen_var_1207, 1 * 8);
+    }
+    uint32_t packetSize_vkCmdDebugMarkerEndEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDebugMarkerEndEXT = OP_vkCmdDebugMarkerEndEXT;
+    stream->write(&opcode_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1208;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1208, 1);
+    stream->write((uint64_t*)&cgen_var_1208, 1 * 8);
+}
+
+void VkEncoder::vkCmdDebugMarkerInsertEXT(
+    VkCommandBuffer commandBuffer,
+    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkDebugMarkerMarkerInfoEXT* local_pMarkerInfo;
+    local_commandBuffer = commandBuffer;
+    local_pMarkerInfo = nullptr;
+    if (pMarkerInfo)
+    {
+        local_pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
+        deepcopy_VkDebugMarkerMarkerInfoEXT(pool, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1209;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1209, 1);
+        countingStream->write((uint64_t*)&cgen_var_1209, 1 * 8);
+        marshal_VkDebugMarkerMarkerInfoEXT(countingStream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+    }
+    uint32_t packetSize_vkCmdDebugMarkerInsertEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDebugMarkerInsertEXT = OP_vkCmdDebugMarkerInsertEXT;
+    stream->write(&opcode_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1210;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1210, 1);
+    stream->write((uint64_t*)&cgen_var_1210, 1 * 8);
+    marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+}
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+void VkEncoder::vkCmdDrawIndirectCountAMD(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    VkBuffer countBuffer,
+    VkDeviceSize countBufferOffset,
+    uint32_t maxDrawCount,
+    uint32_t stride)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_buffer;
+    VkDeviceSize local_offset;
+    VkBuffer local_countBuffer;
+    VkDeviceSize local_countBufferOffset;
+    uint32_t local_maxDrawCount;
+    uint32_t local_stride;
+    local_commandBuffer = commandBuffer;
+    local_buffer = buffer;
+    local_offset = offset;
+    local_countBuffer = countBuffer;
+    local_countBufferOffset = countBufferOffset;
+    local_maxDrawCount = maxDrawCount;
+    local_stride = stride;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1211;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1211, 1);
+        countingStream->write((uint64_t*)&cgen_var_1211, 1 * 8);
+        uint64_t cgen_var_1212;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1212, 1);
+        countingStream->write((uint64_t*)&cgen_var_1212, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+        uint64_t cgen_var_1213;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1213, 1);
+        countingStream->write((uint64_t*)&cgen_var_1213, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+        countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDrawIndirectCountAMD = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDrawIndirectCountAMD = OP_vkCmdDrawIndirectCountAMD;
+    stream->write(&opcode_vkCmdDrawIndirectCountAMD, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDrawIndirectCountAMD, sizeof(uint32_t));
+    uint64_t cgen_var_1214;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1214, 1);
+    stream->write((uint64_t*)&cgen_var_1214, 1 * 8);
+    uint64_t cgen_var_1215;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1215, 1);
+    stream->write((uint64_t*)&cgen_var_1215, 1 * 8);
+    stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+    uint64_t cgen_var_1216;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1216, 1);
+    stream->write((uint64_t*)&cgen_var_1216, 1 * 8);
+    stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+    stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDrawIndexedIndirectCountAMD(
+    VkCommandBuffer commandBuffer,
+    VkBuffer buffer,
+    VkDeviceSize offset,
+    VkBuffer countBuffer,
+    VkDeviceSize countBufferOffset,
+    uint32_t maxDrawCount,
+    uint32_t stride)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkBuffer local_buffer;
+    VkDeviceSize local_offset;
+    VkBuffer local_countBuffer;
+    VkDeviceSize local_countBufferOffset;
+    uint32_t local_maxDrawCount;
+    uint32_t local_stride;
+    local_commandBuffer = commandBuffer;
+    local_buffer = buffer;
+    local_offset = offset;
+    local_countBuffer = countBuffer;
+    local_countBufferOffset = countBufferOffset;
+    local_maxDrawCount = maxDrawCount;
+    local_stride = stride;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1217;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1217, 1);
+        countingStream->write((uint64_t*)&cgen_var_1217, 1 * 8);
+        uint64_t cgen_var_1218;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1218, 1);
+        countingStream->write((uint64_t*)&cgen_var_1218, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+        uint64_t cgen_var_1219;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1219, 1);
+        countingStream->write((uint64_t*)&cgen_var_1219, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+        countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdDrawIndexedIndirectCountAMD = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdDrawIndexedIndirectCountAMD = OP_vkCmdDrawIndexedIndirectCountAMD;
+    stream->write(&opcode_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t));
+    uint64_t cgen_var_1220;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1220, 1);
+    stream->write((uint64_t*)&cgen_var_1220, 1 * 8);
+    uint64_t cgen_var_1221;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1221, 1);
+    stream->write((uint64_t*)&cgen_var_1221, 1 * 8);
+    stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+    uint64_t cgen_var_1222;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1222, 1);
+    stream->write((uint64_t*)&cgen_var_1222, 1 * 8);
+    stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+    stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+VkResult VkEncoder::vkGetShaderInfoAMD(
+    VkDevice device,
+    VkPipeline pipeline,
+    VkShaderStageFlagBits shaderStage,
+    VkShaderInfoTypeAMD infoType,
+    size_t* pInfoSize,
+    void* pInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkPipeline local_pipeline;
+    VkShaderStageFlagBits local_shaderStage;
+    VkShaderInfoTypeAMD local_infoType;
+    local_device = device;
+    local_pipeline = pipeline;
+    local_shaderStage = shaderStage;
+    local_infoType = infoType;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1223;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1223, 1);
+        countingStream->write((uint64_t*)&cgen_var_1223, 1 * 8);
+        uint64_t cgen_var_1224;
+        countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1224, 1);
+        countingStream->write((uint64_t*)&cgen_var_1224, 1 * 8);
+        countingStream->write((VkShaderStageFlagBits*)&local_shaderStage, sizeof(VkShaderStageFlagBits));
+        countingStream->write((VkShaderInfoTypeAMD*)&local_infoType, sizeof(VkShaderInfoTypeAMD));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1225 = (uint64_t)(uintptr_t)pInfoSize;
+        countingStream->putBe64(cgen_var_1225);
+        if (pInfoSize)
+        {
+            uint64_t cgen_var_1226 = (uint64_t)(*pInfoSize);
+            countingStream->putBe64(cgen_var_1226);
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1227 = (uint64_t)(uintptr_t)pInfo;
+        countingStream->putBe64(cgen_var_1227);
+        if (pInfo)
+        {
+            countingStream->write((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
+        }
+    }
+    uint32_t packetSize_vkGetShaderInfoAMD = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetShaderInfoAMD = OP_vkGetShaderInfoAMD;
+    stream->write(&opcode_vkGetShaderInfoAMD, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetShaderInfoAMD, sizeof(uint32_t));
+    uint64_t cgen_var_1228;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1228, 1);
+    stream->write((uint64_t*)&cgen_var_1228, 1 * 8);
+    uint64_t cgen_var_1229;
+    stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1229, 1);
+    stream->write((uint64_t*)&cgen_var_1229, 1 * 8);
+    stream->write((VkShaderStageFlagBits*)&local_shaderStage, sizeof(VkShaderStageFlagBits));
+    stream->write((VkShaderInfoTypeAMD*)&local_infoType, sizeof(VkShaderInfoTypeAMD));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1230 = (uint64_t)(uintptr_t)pInfoSize;
+    stream->putBe64(cgen_var_1230);
+    if (pInfoSize)
+    {
+        uint64_t cgen_var_1231 = (uint64_t)(*pInfoSize);
+        stream->putBe64(cgen_var_1231);
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1232 = (uint64_t)(uintptr_t)pInfo;
+    stream->putBe64(cgen_var_1232);
+    if (pInfo)
+    {
+        stream->write((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
+    }
+    // WARNING PTR CHECK
+    size_t* check_pInfoSize;
+    check_pInfoSize = (size_t*)(uintptr_t)stream->getBe64();
+    if (pInfoSize)
+    {
+        if (!(check_pInfoSize))
+        {
+            fprintf(stderr, "fatal: pInfoSize inconsistent between guest and host\n");
+        }
+        (*pInfoSize) = (size_t)stream->getBe64();
+    }
+    // WARNING PTR CHECK
+    void* check_pInfo;
+    check_pInfo = (void*)(uintptr_t)stream->getBe64();
+    if (pInfo)
+    {
+        if (!(check_pInfo))
+        {
+            fprintf(stderr, "fatal: pInfo inconsistent between guest and host\n");
+        }
+        stream->read((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
+    }
+    VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
+    stream->read(&vkGetShaderInfoAMD_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetShaderInfoAMD_VkResult_return;
+}
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+VkResult VkEncoder::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice physicalDevice,
+    VkFormat format,
+    VkImageType type,
+    VkImageTiling tiling,
+    VkImageUsageFlags usage,
+    VkImageCreateFlags flags,
+    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+    VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkFormat local_format;
+    VkImageType local_type;
+    VkImageTiling local_tiling;
+    VkImageUsageFlags local_usage;
+    VkImageCreateFlags local_flags;
+    VkExternalMemoryHandleTypeFlagsNV local_externalHandleType;
+    local_physicalDevice = physicalDevice;
+    local_format = format;
+    local_type = type;
+    local_tiling = tiling;
+    local_usage = usage;
+    local_flags = flags;
+    local_externalHandleType = externalHandleType;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1236;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1236, 1);
+        countingStream->write((uint64_t*)&cgen_var_1236, 1 * 8);
+        countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+        countingStream->write((VkImageType*)&local_type, sizeof(VkImageType));
+        countingStream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+        countingStream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+        countingStream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
+        countingStream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_externalHandleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+        marshal_VkExternalImageFormatPropertiesNV(countingStream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
+    stream->write(&opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t));
+    uint64_t cgen_var_1237;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1237, 1);
+    stream->write((uint64_t*)&cgen_var_1237, 1 * 8);
+    stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+    stream->write((VkImageType*)&local_type, sizeof(VkImageType));
+    stream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+    stream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+    stream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
+    stream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_externalHandleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+    marshal_VkExternalImageFormatPropertiesNV(stream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
+    unmarshal_VkExternalImageFormatPropertiesNV(stream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
+    VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return;
+}
+
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+VkResult VkEncoder::vkGetMemoryWin32HandleNV(
+    VkDevice device,
+    VkDeviceMemory memory,
+    VkExternalMemoryHandleTypeFlagsNV handleType,
+    HANDLE* pHandle)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDeviceMemory local_memory;
+    VkExternalMemoryHandleTypeFlagsNV local_handleType;
+    local_device = device;
+    local_memory = memory;
+    local_handleType = handleType;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1238;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1238, 1);
+        countingStream->write((uint64_t*)&cgen_var_1238, 1 * 8);
+        uint64_t cgen_var_1239;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1239, 1);
+        countingStream->write((uint64_t*)&cgen_var_1239, 1 * 8);
+        countingStream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+        countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
+    }
+    uint32_t packetSize_vkGetMemoryWin32HandleNV = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetMemoryWin32HandleNV = OP_vkGetMemoryWin32HandleNV;
+    stream->write(&opcode_vkGetMemoryWin32HandleNV, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetMemoryWin32HandleNV, sizeof(uint32_t));
+    uint64_t cgen_var_1240;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1240, 1);
+    stream->write((uint64_t*)&cgen_var_1240, 1 * 8);
+    uint64_t cgen_var_1241;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1241, 1);
+    stream->write((uint64_t*)&cgen_var_1241, 1 * 8);
+    stream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+    stream->write((HANDLE*)pHandle, sizeof(HANDLE));
+    stream->read((HANDLE*)pHandle, sizeof(HANDLE));
+    VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
+    stream->read(&vkGetMemoryWin32HandleNV_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetMemoryWin32HandleNV_VkResult_return;
+}
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+VkResult VkEncoder::vkCreateViSurfaceNN(
+    VkInstance instance,
+    const VkViSurfaceCreateInfoNN* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkViSurfaceCreateInfoNN* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkViSurfaceCreateInfoNN*)pool->alloc(sizeof(const VkViSurfaceCreateInfoNN));
+        deepcopy_VkViSurfaceCreateInfoNN(pool, pCreateInfo, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1242;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1242, 1);
+        countingStream->write((uint64_t*)&cgen_var_1242, 1 * 8);
+        marshal_VkViSurfaceCreateInfoNN(countingStream, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1243 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1243);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1244;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1244, 1);
+        countingStream->write((uint64_t*)&cgen_var_1244, 8);
+    }
+    uint32_t packetSize_vkCreateViSurfaceNN = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateViSurfaceNN = OP_vkCreateViSurfaceNN;
+    stream->write(&opcode_vkCreateViSurfaceNN, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateViSurfaceNN, sizeof(uint32_t));
+    uint64_t cgen_var_1245;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1245, 1);
+    stream->write((uint64_t*)&cgen_var_1245, 1 * 8);
+    marshal_VkViSurfaceCreateInfoNN(stream, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1246 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1246);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1247;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1247, 1);
+    stream->write((uint64_t*)&cgen_var_1247, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_1248;
+    stream->read((uint64_t*)&cgen_var_1248, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1248, (VkSurfaceKHR*)pSurface, 1);
+    VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateViSurfaceNN_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateViSurfaceNN_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void VkEncoder::vkCmdBeginConditionalRenderingEXT(
+    VkCommandBuffer commandBuffer,
+    const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkConditionalRenderingBeginInfoEXT* local_pConditionalRenderingBegin;
+    local_commandBuffer = commandBuffer;
+    local_pConditionalRenderingBegin = nullptr;
+    if (pConditionalRenderingBegin)
+    {
+        local_pConditionalRenderingBegin = (VkConditionalRenderingBeginInfoEXT*)pool->alloc(sizeof(const VkConditionalRenderingBeginInfoEXT));
+        deepcopy_VkConditionalRenderingBeginInfoEXT(pool, pConditionalRenderingBegin, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1249;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1249, 1);
+        countingStream->write((uint64_t*)&cgen_var_1249, 1 * 8);
+        marshal_VkConditionalRenderingBeginInfoEXT(countingStream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
+    }
+    uint32_t packetSize_vkCmdBeginConditionalRenderingEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdBeginConditionalRenderingEXT = OP_vkCmdBeginConditionalRenderingEXT;
+    stream->write(&opcode_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1250;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1250, 1);
+    stream->write((uint64_t*)&cgen_var_1250, 1 * 8);
+    marshal_VkConditionalRenderingBeginInfoEXT(stream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
+}
+
+void VkEncoder::vkCmdEndConditionalRenderingEXT(
+    VkCommandBuffer commandBuffer)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    local_commandBuffer = commandBuffer;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1251;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1251, 1);
+        countingStream->write((uint64_t*)&cgen_var_1251, 1 * 8);
+    }
+    uint32_t packetSize_vkCmdEndConditionalRenderingEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdEndConditionalRenderingEXT = OP_vkCmdEndConditionalRenderingEXT;
+    stream->write(&opcode_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1252;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1252, 1);
+    stream->write((uint64_t*)&cgen_var_1252, 1 * 8);
+}
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void VkEncoder::vkCmdProcessCommandsNVX(
+    VkCommandBuffer commandBuffer,
+    const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkCmdProcessCommandsInfoNVX* local_pProcessCommandsInfo;
+    local_commandBuffer = commandBuffer;
+    local_pProcessCommandsInfo = nullptr;
+    if (pProcessCommandsInfo)
+    {
+        local_pProcessCommandsInfo = (VkCmdProcessCommandsInfoNVX*)pool->alloc(sizeof(const VkCmdProcessCommandsInfoNVX));
+        deepcopy_VkCmdProcessCommandsInfoNVX(pool, pProcessCommandsInfo, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1253;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1253, 1);
+        countingStream->write((uint64_t*)&cgen_var_1253, 1 * 8);
+        marshal_VkCmdProcessCommandsInfoNVX(countingStream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
+    }
+    uint32_t packetSize_vkCmdProcessCommandsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdProcessCommandsNVX = OP_vkCmdProcessCommandsNVX;
+    stream->write(&opcode_vkCmdProcessCommandsNVX, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdProcessCommandsNVX, sizeof(uint32_t));
+    uint64_t cgen_var_1254;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1254, 1);
+    stream->write((uint64_t*)&cgen_var_1254, 1 * 8);
+    marshal_VkCmdProcessCommandsInfoNVX(stream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
+}
+
+void VkEncoder::vkCmdReserveSpaceForCommandsNVX(
+    VkCommandBuffer commandBuffer,
+    const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkCmdReserveSpaceForCommandsInfoNVX* local_pReserveSpaceInfo;
+    local_commandBuffer = commandBuffer;
+    local_pReserveSpaceInfo = nullptr;
+    if (pReserveSpaceInfo)
+    {
+        local_pReserveSpaceInfo = (VkCmdReserveSpaceForCommandsInfoNVX*)pool->alloc(sizeof(const VkCmdReserveSpaceForCommandsInfoNVX));
+        deepcopy_VkCmdReserveSpaceForCommandsInfoNVX(pool, pReserveSpaceInfo, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1255;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1255, 1);
+        countingStream->write((uint64_t*)&cgen_var_1255, 1 * 8);
+        marshal_VkCmdReserveSpaceForCommandsInfoNVX(countingStream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
+    }
+    uint32_t packetSize_vkCmdReserveSpaceForCommandsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdReserveSpaceForCommandsNVX = OP_vkCmdReserveSpaceForCommandsNVX;
+    stream->write(&opcode_vkCmdReserveSpaceForCommandsNVX, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdReserveSpaceForCommandsNVX, sizeof(uint32_t));
+    uint64_t cgen_var_1256;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1256, 1);
+    stream->write((uint64_t*)&cgen_var_1256, 1 * 8);
+    marshal_VkCmdReserveSpaceForCommandsInfoNVX(stream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
+}
+
+VkResult VkEncoder::vkCreateIndirectCommandsLayoutNVX(
+    VkDevice device,
+    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkIndirectCommandsLayoutCreateInfoNVX* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkIndirectCommandsLayoutCreateInfoNVX*)pool->alloc(sizeof(const VkIndirectCommandsLayoutCreateInfoNVX));
+        deepcopy_VkIndirectCommandsLayoutCreateInfoNVX(pool, pCreateInfo, (VkIndirectCommandsLayoutCreateInfoNVX*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1257;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1257, 1);
+        countingStream->write((uint64_t*)&cgen_var_1257, 1 * 8);
+        marshal_VkIndirectCommandsLayoutCreateInfoNVX(countingStream, (VkIndirectCommandsLayoutCreateInfoNVX*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1258 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1258);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1259;
+        countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1259, 1);
+        countingStream->write((uint64_t*)&cgen_var_1259, 8);
+    }
+    uint32_t packetSize_vkCreateIndirectCommandsLayoutNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateIndirectCommandsLayoutNVX = OP_vkCreateIndirectCommandsLayoutNVX;
+    stream->write(&opcode_vkCreateIndirectCommandsLayoutNVX, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateIndirectCommandsLayoutNVX, sizeof(uint32_t));
+    uint64_t cgen_var_1260;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1260, 1);
+    stream->write((uint64_t*)&cgen_var_1260, 1 * 8);
+    marshal_VkIndirectCommandsLayoutCreateInfoNVX(stream, (VkIndirectCommandsLayoutCreateInfoNVX*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1261 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1261);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1262;
+    stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1262, 1);
+    stream->write((uint64_t*)&cgen_var_1262, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_1263;
+    stream->read((uint64_t*)&cgen_var_1263, 8);
+    stream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_1263, (VkIndirectCommandsLayoutNVX*)pIndirectCommandsLayout, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateIndirectCommandsLayoutNVX_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateIndirectCommandsLayoutNVX_VkResult_return;
+}
+
+void VkEncoder::vkDestroyIndirectCommandsLayoutNVX(
+    VkDevice device,
+    VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkIndirectCommandsLayoutNVX local_indirectCommandsLayout;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_indirectCommandsLayout = indirectCommandsLayout;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1264;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1264, 1);
+        countingStream->write((uint64_t*)&cgen_var_1264, 1 * 8);
+        uint64_t cgen_var_1265;
+        countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1265, 1);
+        countingStream->write((uint64_t*)&cgen_var_1265, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1266 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1266);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyIndirectCommandsLayoutNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyIndirectCommandsLayoutNVX = OP_vkDestroyIndirectCommandsLayoutNVX;
+    stream->write(&opcode_vkDestroyIndirectCommandsLayoutNVX, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyIndirectCommandsLayoutNVX, sizeof(uint32_t));
+    uint64_t cgen_var_1267;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1267, 1);
+    stream->write((uint64_t*)&cgen_var_1267, 1 * 8);
+    uint64_t cgen_var_1268;
+    stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1268, 1);
+    stream->write((uint64_t*)&cgen_var_1268, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1269 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1269);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&indirectCommandsLayout);
+}
+
+VkResult VkEncoder::vkCreateObjectTableNVX(
+    VkDevice device,
+    const VkObjectTableCreateInfoNVX* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkObjectTableNVX* pObjectTable)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkObjectTableCreateInfoNVX* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkObjectTableCreateInfoNVX*)pool->alloc(sizeof(const VkObjectTableCreateInfoNVX));
+        deepcopy_VkObjectTableCreateInfoNVX(pool, pCreateInfo, (VkObjectTableCreateInfoNVX*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1270;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1270, 1);
+        countingStream->write((uint64_t*)&cgen_var_1270, 1 * 8);
+        marshal_VkObjectTableCreateInfoNVX(countingStream, (VkObjectTableCreateInfoNVX*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1271 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1271);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1272;
+        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1272, 1);
+        countingStream->write((uint64_t*)&cgen_var_1272, 8);
+    }
+    uint32_t packetSize_vkCreateObjectTableNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateObjectTableNVX = OP_vkCreateObjectTableNVX;
+    stream->write(&opcode_vkCreateObjectTableNVX, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateObjectTableNVX, sizeof(uint32_t));
+    uint64_t cgen_var_1273;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1273, 1);
+    stream->write((uint64_t*)&cgen_var_1273, 1 * 8);
+    marshal_VkObjectTableCreateInfoNVX(stream, (VkObjectTableCreateInfoNVX*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1274 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1274);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1275;
+    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1275, 1);
+    stream->write((uint64_t*)&cgen_var_1275, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_1276;
+    stream->read((uint64_t*)&cgen_var_1276, 8);
+    stream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_1276, (VkObjectTableNVX*)pObjectTable, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateObjectTableNVX_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateObjectTableNVX_VkResult_return;
+}
+
+void VkEncoder::vkDestroyObjectTableNVX(
+    VkDevice device,
+    VkObjectTableNVX objectTable,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkObjectTableNVX local_objectTable;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_objectTable = objectTable;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1277;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1277, 1);
+        countingStream->write((uint64_t*)&cgen_var_1277, 1 * 8);
+        uint64_t cgen_var_1278;
+        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1278, 1);
+        countingStream->write((uint64_t*)&cgen_var_1278, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1279 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1279);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyObjectTableNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyObjectTableNVX = OP_vkDestroyObjectTableNVX;
+    stream->write(&opcode_vkDestroyObjectTableNVX, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyObjectTableNVX, sizeof(uint32_t));
+    uint64_t cgen_var_1280;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1280, 1);
+    stream->write((uint64_t*)&cgen_var_1280, 1 * 8);
+    uint64_t cgen_var_1281;
+    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1281, 1);
+    stream->write((uint64_t*)&cgen_var_1281, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1282 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1282);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&objectTable);
+}
+
+VkResult VkEncoder::vkRegisterObjectsNVX(
+    VkDevice device,
+    VkObjectTableNVX objectTable,
+    uint32_t objectCount,
+    const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+    const uint32_t* pObjectIndices)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkObjectTableNVX local_objectTable;
+    uint32_t local_objectCount;
+    VkObjectTableEntryNVX** local_ppObjectTableEntries;
+    uint32_t* local_pObjectIndices;
+    local_device = device;
+    local_objectTable = objectTable;
+    local_objectCount = objectCount;
+    (void)ppObjectTableEntries;
+    local_pObjectIndices = nullptr;
+    if (pObjectIndices)
+    {
+        local_pObjectIndices = (uint32_t*)pool->dupArray(pObjectIndices, ((objectCount)) * sizeof(const uint32_t));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1283;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1283, 1);
+        countingStream->write((uint64_t*)&cgen_var_1283, 1 * 8);
+        uint64_t cgen_var_1284;
+        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1284, 1);
+        countingStream->write((uint64_t*)&cgen_var_1284, 1 * 8);
+        countingStream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
+        (void)local_ppObjectTableEntries;
+        countingStream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkRegisterObjectsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkRegisterObjectsNVX = OP_vkRegisterObjectsNVX;
+    stream->write(&opcode_vkRegisterObjectsNVX, sizeof(uint32_t));
+    stream->write(&packetSize_vkRegisterObjectsNVX, sizeof(uint32_t));
+    uint64_t cgen_var_1285;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1285, 1);
+    stream->write((uint64_t*)&cgen_var_1285, 1 * 8);
+    uint64_t cgen_var_1286;
+    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1286, 1);
+    stream->write((uint64_t*)&cgen_var_1286, 1 * 8);
+    stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
+    (void)local_ppObjectTableEntries;
+    stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
+    VkResult vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
+    stream->read(&vkRegisterObjectsNVX_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkRegisterObjectsNVX_VkResult_return;
+}
+
+VkResult VkEncoder::vkUnregisterObjectsNVX(
+    VkDevice device,
+    VkObjectTableNVX objectTable,
+    uint32_t objectCount,
+    const VkObjectEntryTypeNVX* pObjectEntryTypes,
+    const uint32_t* pObjectIndices)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkObjectTableNVX local_objectTable;
+    uint32_t local_objectCount;
+    VkObjectEntryTypeNVX* local_pObjectEntryTypes;
+    uint32_t* local_pObjectIndices;
+    local_device = device;
+    local_objectTable = objectTable;
+    local_objectCount = objectCount;
+    local_pObjectEntryTypes = nullptr;
+    if (pObjectEntryTypes)
+    {
+        local_pObjectEntryTypes = (VkObjectEntryTypeNVX*)pool->dupArray(pObjectEntryTypes, ((objectCount)) * sizeof(const VkObjectEntryTypeNVX));
+    }
+    local_pObjectIndices = nullptr;
+    if (pObjectIndices)
+    {
+        local_pObjectIndices = (uint32_t*)pool->dupArray(pObjectIndices, ((objectCount)) * sizeof(const uint32_t));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1287;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1287, 1);
+        countingStream->write((uint64_t*)&cgen_var_1287, 1 * 8);
+        uint64_t cgen_var_1288;
+        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1288, 1);
+        countingStream->write((uint64_t*)&cgen_var_1288, 1 * 8);
+        countingStream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
+        countingStream->write((VkObjectEntryTypeNVX*)local_pObjectEntryTypes, ((objectCount)) * sizeof(VkObjectEntryTypeNVX));
+        countingStream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkUnregisterObjectsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkUnregisterObjectsNVX = OP_vkUnregisterObjectsNVX;
+    stream->write(&opcode_vkUnregisterObjectsNVX, sizeof(uint32_t));
+    stream->write(&packetSize_vkUnregisterObjectsNVX, sizeof(uint32_t));
+    uint64_t cgen_var_1289;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1289, 1);
+    stream->write((uint64_t*)&cgen_var_1289, 1 * 8);
+    uint64_t cgen_var_1290;
+    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1290, 1);
+    stream->write((uint64_t*)&cgen_var_1290, 1 * 8);
+    stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
+    stream->write((VkObjectEntryTypeNVX*)local_pObjectEntryTypes, ((objectCount)) * sizeof(VkObjectEntryTypeNVX));
+    stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
+    VkResult vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
+    stream->read(&vkUnregisterObjectsNVX_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkUnregisterObjectsNVX_VkResult_return;
+}
+
+void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    VkPhysicalDevice physicalDevice,
+    VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+    VkDeviceGeneratedCommandsLimitsNVX* pLimits)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1291;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1291, 1);
+        countingStream->write((uint64_t*)&cgen_var_1291, 1 * 8);
+        marshal_VkDeviceGeneratedCommandsFeaturesNVX(countingStream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
+        marshal_VkDeviceGeneratedCommandsLimitsNVX(countingStream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = OP_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+    stream->write(&opcode_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX, sizeof(uint32_t));
+    uint64_t cgen_var_1292;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1292, 1);
+    stream->write((uint64_t*)&cgen_var_1292, 1 * 8);
+    marshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
+    marshal_VkDeviceGeneratedCommandsLimitsNVX(stream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
+    unmarshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
+    unmarshal_VkDeviceGeneratedCommandsLimitsNVX(stream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
+}
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void VkEncoder::vkCmdSetViewportWScalingNV(
+    VkCommandBuffer commandBuffer,
+    uint32_t firstViewport,
+    uint32_t viewportCount,
+    const VkViewportWScalingNV* pViewportWScalings)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_firstViewport;
+    uint32_t local_viewportCount;
+    VkViewportWScalingNV* local_pViewportWScalings;
+    local_commandBuffer = commandBuffer;
+    local_firstViewport = firstViewport;
+    local_viewportCount = viewportCount;
+    local_pViewportWScalings = nullptr;
+    if (pViewportWScalings)
+    {
+        local_pViewportWScalings = (VkViewportWScalingNV*)pool->alloc(((viewportCount)) * sizeof(const VkViewportWScalingNV));
+        for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+        {
+            deepcopy_VkViewportWScalingNV(pool, pViewportWScalings + i, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1293;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1293, 1);
+        countingStream->write((uint64_t*)&cgen_var_1293, 1 * 8);
+        countingStream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+        {
+            marshal_VkViewportWScalingNV(countingStream, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
+        }
+    }
+    uint32_t packetSize_vkCmdSetViewportWScalingNV = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetViewportWScalingNV = OP_vkCmdSetViewportWScalingNV;
+    stream->write(&opcode_vkCmdSetViewportWScalingNV, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetViewportWScalingNV, sizeof(uint32_t));
+    uint64_t cgen_var_1294;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1294, 1);
+    stream->write((uint64_t*)&cgen_var_1294, 1 * 8);
+    stream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+    {
+        marshal_VkViewportWScalingNV(stream, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
+    }
+}
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+VkResult VkEncoder::vkReleaseDisplayEXT(
+    VkPhysicalDevice physicalDevice,
+    VkDisplayKHR display)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkDisplayKHR local_display;
+    local_physicalDevice = physicalDevice;
+    local_display = display;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1295;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1295, 1);
+        countingStream->write((uint64_t*)&cgen_var_1295, 1 * 8);
+        uint64_t cgen_var_1296;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1296, 1);
+        countingStream->write((uint64_t*)&cgen_var_1296, 1 * 8);
+    }
+    uint32_t packetSize_vkReleaseDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkReleaseDisplayEXT = OP_vkReleaseDisplayEXT;
+    stream->write(&opcode_vkReleaseDisplayEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkReleaseDisplayEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1297;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1297, 1);
+    stream->write((uint64_t*)&cgen_var_1297, 1 * 8);
+    uint64_t cgen_var_1298;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1298, 1);
+    stream->write((uint64_t*)&cgen_var_1298, 1 * 8);
+    VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkReleaseDisplayEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkReleaseDisplayEXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+VkResult VkEncoder::vkAcquireXlibDisplayEXT(
+    VkPhysicalDevice physicalDevice,
+    Display* dpy,
+    VkDisplayKHR display)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkDisplayKHR local_display;
+    local_physicalDevice = physicalDevice;
+    local_display = display;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1299;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1299, 1);
+        countingStream->write((uint64_t*)&cgen_var_1299, 1 * 8);
+        countingStream->write((Display*)dpy, sizeof(Display));
+        uint64_t cgen_var_1300;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1300, 1);
+        countingStream->write((uint64_t*)&cgen_var_1300, 1 * 8);
+    }
+    uint32_t packetSize_vkAcquireXlibDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkAcquireXlibDisplayEXT = OP_vkAcquireXlibDisplayEXT;
+    stream->write(&opcode_vkAcquireXlibDisplayEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkAcquireXlibDisplayEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1301;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1301, 1);
+    stream->write((uint64_t*)&cgen_var_1301, 1 * 8);
+    stream->write((Display*)dpy, sizeof(Display));
+    uint64_t cgen_var_1302;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1302, 1);
+    stream->write((uint64_t*)&cgen_var_1302, 1 * 8);
+    stream->read((Display*)dpy, sizeof(Display));
+    VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkAcquireXlibDisplayEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkAcquireXlibDisplayEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetRandROutputDisplayEXT(
+    VkPhysicalDevice physicalDevice,
+    Display* dpy,
+    RROutput rrOutput,
+    VkDisplayKHR* pDisplay)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    RROutput local_rrOutput;
+    local_physicalDevice = physicalDevice;
+    local_rrOutput = rrOutput;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1303;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1303, 1);
+        countingStream->write((uint64_t*)&cgen_var_1303, 1 * 8);
+        countingStream->write((Display*)dpy, sizeof(Display));
+        countingStream->write((RROutput*)&local_rrOutput, sizeof(RROutput));
+        uint64_t cgen_var_1304;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1304, 1);
+        countingStream->write((uint64_t*)&cgen_var_1304, 8);
+    }
+    uint32_t packetSize_vkGetRandROutputDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetRandROutputDisplayEXT = OP_vkGetRandROutputDisplayEXT;
+    stream->write(&opcode_vkGetRandROutputDisplayEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetRandROutputDisplayEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1305;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1305, 1);
+    stream->write((uint64_t*)&cgen_var_1305, 1 * 8);
+    stream->write((Display*)dpy, sizeof(Display));
+    stream->write((RROutput*)&local_rrOutput, sizeof(RROutput));
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1306;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1306, 1);
+    stream->write((uint64_t*)&cgen_var_1306, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->read((Display*)dpy, sizeof(Display));
+    uint64_t cgen_var_1307;
+    stream->read((uint64_t*)&cgen_var_1307, 8);
+    stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_1307, (VkDisplayKHR*)pDisplay, 1);
+    VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkGetRandROutputDisplayEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetRandROutputDisplayEXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_display_surface_counter
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+    VkPhysicalDevice physicalDevice,
+    VkSurfaceKHR surface,
+    VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkSurfaceKHR local_surface;
+    local_physicalDevice = physicalDevice;
+    local_surface = surface;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1308;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1308, 1);
+        countingStream->write((uint64_t*)&cgen_var_1308, 1 * 8);
+        uint64_t cgen_var_1309;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1309, 1);
+        countingStream->write((uint64_t*)&cgen_var_1309, 1 * 8);
+        marshal_VkSurfaceCapabilities2EXT(countingStream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT = OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+    stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t));
+    uint64_t cgen_var_1310;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1310, 1);
+    stream->write((uint64_t*)&cgen_var_1310, 1 * 8);
+    uint64_t cgen_var_1311;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1311, 1);
+    stream->write((uint64_t*)&cgen_var_1311, 1 * 8);
+    marshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
+    unmarshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_display_control
+VkResult VkEncoder::vkDisplayPowerControlEXT(
+    VkDevice device,
+    VkDisplayKHR display,
+    const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDisplayKHR local_display;
+    VkDisplayPowerInfoEXT* local_pDisplayPowerInfo;
+    local_device = device;
+    local_display = display;
+    local_pDisplayPowerInfo = nullptr;
+    if (pDisplayPowerInfo)
+    {
+        local_pDisplayPowerInfo = (VkDisplayPowerInfoEXT*)pool->alloc(sizeof(const VkDisplayPowerInfoEXT));
+        deepcopy_VkDisplayPowerInfoEXT(pool, pDisplayPowerInfo, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1312;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1312, 1);
+        countingStream->write((uint64_t*)&cgen_var_1312, 1 * 8);
+        uint64_t cgen_var_1313;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1313, 1);
+        countingStream->write((uint64_t*)&cgen_var_1313, 1 * 8);
+        marshal_VkDisplayPowerInfoEXT(countingStream, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
+    }
+    uint32_t packetSize_vkDisplayPowerControlEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDisplayPowerControlEXT = OP_vkDisplayPowerControlEXT;
+    stream->write(&opcode_vkDisplayPowerControlEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkDisplayPowerControlEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1314;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1314, 1);
+    stream->write((uint64_t*)&cgen_var_1314, 1 * 8);
+    uint64_t cgen_var_1315;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1315, 1);
+    stream->write((uint64_t*)&cgen_var_1315, 1 * 8);
+    marshal_VkDisplayPowerInfoEXT(stream, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
+    VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkDisplayPowerControlEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkDisplayPowerControlEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkRegisterDeviceEventEXT(
+    VkDevice device,
+    const VkDeviceEventInfoEXT* pDeviceEventInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkFence* pFence)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDeviceEventInfoEXT* local_pDeviceEventInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pDeviceEventInfo = nullptr;
+    if (pDeviceEventInfo)
+    {
+        local_pDeviceEventInfo = (VkDeviceEventInfoEXT*)pool->alloc(sizeof(const VkDeviceEventInfoEXT));
+        deepcopy_VkDeviceEventInfoEXT(pool, pDeviceEventInfo, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1316;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1316, 1);
+        countingStream->write((uint64_t*)&cgen_var_1316, 1 * 8);
+        marshal_VkDeviceEventInfoEXT(countingStream, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1317 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1317);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1318;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1318, 1);
+        countingStream->write((uint64_t*)&cgen_var_1318, 8);
+    }
+    uint32_t packetSize_vkRegisterDeviceEventEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkRegisterDeviceEventEXT = OP_vkRegisterDeviceEventEXT;
+    stream->write(&opcode_vkRegisterDeviceEventEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkRegisterDeviceEventEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1319;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1319, 1);
+    stream->write((uint64_t*)&cgen_var_1319, 1 * 8);
+    marshal_VkDeviceEventInfoEXT(stream, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1320 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1320);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1321;
+    stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1321, 1);
+    stream->write((uint64_t*)&cgen_var_1321, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_1322;
+    stream->read((uint64_t*)&cgen_var_1322, 8);
+    stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1322, (VkFence*)pFence, 1);
+    VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkRegisterDeviceEventEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkRegisterDeviceEventEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkRegisterDisplayEventEXT(
+    VkDevice device,
+    VkDisplayKHR display,
+    const VkDisplayEventInfoEXT* pDisplayEventInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkFence* pFence)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDisplayKHR local_display;
+    VkDisplayEventInfoEXT* local_pDisplayEventInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_display = display;
+    local_pDisplayEventInfo = nullptr;
+    if (pDisplayEventInfo)
+    {
+        local_pDisplayEventInfo = (VkDisplayEventInfoEXT*)pool->alloc(sizeof(const VkDisplayEventInfoEXT));
+        deepcopy_VkDisplayEventInfoEXT(pool, pDisplayEventInfo, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1323;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1323, 1);
+        countingStream->write((uint64_t*)&cgen_var_1323, 1 * 8);
+        uint64_t cgen_var_1324;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1324, 1);
+        countingStream->write((uint64_t*)&cgen_var_1324, 1 * 8);
+        marshal_VkDisplayEventInfoEXT(countingStream, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1325 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1325);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1326;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1326, 1);
+        countingStream->write((uint64_t*)&cgen_var_1326, 8);
+    }
+    uint32_t packetSize_vkRegisterDisplayEventEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkRegisterDisplayEventEXT = OP_vkRegisterDisplayEventEXT;
+    stream->write(&opcode_vkRegisterDisplayEventEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkRegisterDisplayEventEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1327;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1327, 1);
+    stream->write((uint64_t*)&cgen_var_1327, 1 * 8);
+    uint64_t cgen_var_1328;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1328, 1);
+    stream->write((uint64_t*)&cgen_var_1328, 1 * 8);
+    marshal_VkDisplayEventInfoEXT(stream, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1329 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1329);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1330;
+    stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1330, 1);
+    stream->write((uint64_t*)&cgen_var_1330, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_1331;
+    stream->read((uint64_t*)&cgen_var_1331, 8);
+    stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1331, (VkFence*)pFence, 1);
+    VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkRegisterDisplayEventEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkRegisterDisplayEventEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetSwapchainCounterEXT(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    VkSurfaceCounterFlagBitsEXT counter,
+    uint64_t* pCounterValue)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSwapchainKHR local_swapchain;
+    VkSurfaceCounterFlagBitsEXT local_counter;
+    local_device = device;
+    local_swapchain = swapchain;
+    local_counter = counter;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1332;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1332, 1);
+        countingStream->write((uint64_t*)&cgen_var_1332, 1 * 8);
+        uint64_t cgen_var_1333;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1333, 1);
+        countingStream->write((uint64_t*)&cgen_var_1333, 1 * 8);
+        countingStream->write((VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT));
+        countingStream->write((uint64_t*)pCounterValue, sizeof(uint64_t));
+    }
+    uint32_t packetSize_vkGetSwapchainCounterEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetSwapchainCounterEXT = OP_vkGetSwapchainCounterEXT;
+    stream->write(&opcode_vkGetSwapchainCounterEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetSwapchainCounterEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1334;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1334, 1);
+    stream->write((uint64_t*)&cgen_var_1334, 1 * 8);
+    uint64_t cgen_var_1335;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1335, 1);
+    stream->write((uint64_t*)&cgen_var_1335, 1 * 8);
+    stream->write((VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT));
+    stream->write((uint64_t*)pCounterValue, sizeof(uint64_t));
+    stream->read((uint64_t*)pCounterValue, sizeof(uint64_t));
+    VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkGetSwapchainCounterEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetSwapchainCounterEXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+VkResult VkEncoder::vkGetRefreshCycleDurationGOOGLE(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSwapchainKHR local_swapchain;
+    local_device = device;
+    local_swapchain = swapchain;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1336;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1336, 1);
+        countingStream->write((uint64_t*)&cgen_var_1336, 1 * 8);
+        uint64_t cgen_var_1337;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1337, 1);
+        countingStream->write((uint64_t*)&cgen_var_1337, 1 * 8);
+        marshal_VkRefreshCycleDurationGOOGLE(countingStream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
+    }
+    uint32_t packetSize_vkGetRefreshCycleDurationGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetRefreshCycleDurationGOOGLE = OP_vkGetRefreshCycleDurationGOOGLE;
+    stream->write(&opcode_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t));
+    uint64_t cgen_var_1338;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1338, 1);
+    stream->write((uint64_t*)&cgen_var_1338, 1 * 8);
+    uint64_t cgen_var_1339;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1339, 1);
+    stream->write((uint64_t*)&cgen_var_1339, 1 * 8);
+    marshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
+    unmarshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
+    VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
+    stream->read(&vkGetRefreshCycleDurationGOOGLE_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetRefreshCycleDurationGOOGLE_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    uint32_t* pPresentationTimingCount,
+    VkPastPresentationTimingGOOGLE* pPresentationTimings)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkSwapchainKHR local_swapchain;
+    local_device = device;
+    local_swapchain = swapchain;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1340;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1340, 1);
+        countingStream->write((uint64_t*)&cgen_var_1340, 1 * 8);
+        uint64_t cgen_var_1341;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1341, 1);
+        countingStream->write((uint64_t*)&cgen_var_1341, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1342 = (uint64_t)(uintptr_t)pPresentationTimingCount;
+        countingStream->putBe64(cgen_var_1342);
+        if (pPresentationTimingCount)
+        {
+            countingStream->write((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1343 = (uint64_t)(uintptr_t)pPresentationTimings;
+        countingStream->putBe64(cgen_var_1343);
+        if (pPresentationTimings)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
+            {
+                marshal_VkPastPresentationTimingGOOGLE(countingStream, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetPastPresentationTimingGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPastPresentationTimingGOOGLE = OP_vkGetPastPresentationTimingGOOGLE;
+    stream->write(&opcode_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t));
+    uint64_t cgen_var_1344;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1344, 1);
+    stream->write((uint64_t*)&cgen_var_1344, 1 * 8);
+    uint64_t cgen_var_1345;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1345, 1);
+    stream->write((uint64_t*)&cgen_var_1345, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1346 = (uint64_t)(uintptr_t)pPresentationTimingCount;
+    stream->putBe64(cgen_var_1346);
+    if (pPresentationTimingCount)
+    {
+        stream->write((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1347 = (uint64_t)(uintptr_t)pPresentationTimings;
+    stream->putBe64(cgen_var_1347);
+    if (pPresentationTimings)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
+        {
+            marshal_VkPastPresentationTimingGOOGLE(stream, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPresentationTimingCount;
+    check_pPresentationTimingCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPresentationTimingCount)
+    {
+        if (!(check_pPresentationTimingCount))
+        {
+            fprintf(stderr, "fatal: pPresentationTimingCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkPastPresentationTimingGOOGLE* check_pPresentationTimings;
+    check_pPresentationTimings = (VkPastPresentationTimingGOOGLE*)(uintptr_t)stream->getBe64();
+    if (pPresentationTimings)
+    {
+        if (!(check_pPresentationTimings))
+        {
+            fprintf(stderr, "fatal: pPresentationTimings inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
+        {
+            unmarshal_VkPastPresentationTimingGOOGLE(stream, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
+        }
+    }
+    VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
+    stream->read(&vkGetPastPresentationTimingGOOGLE_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetPastPresentationTimingGOOGLE_VkResult_return;
+}
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+void VkEncoder::vkCmdSetDiscardRectangleEXT(
+    VkCommandBuffer commandBuffer,
+    uint32_t firstDiscardRectangle,
+    uint32_t discardRectangleCount,
+    const VkRect2D* pDiscardRectangles)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    uint32_t local_firstDiscardRectangle;
+    uint32_t local_discardRectangleCount;
+    VkRect2D* local_pDiscardRectangles;
+    local_commandBuffer = commandBuffer;
+    local_firstDiscardRectangle = firstDiscardRectangle;
+    local_discardRectangleCount = discardRectangleCount;
+    local_pDiscardRectangles = nullptr;
+    if (pDiscardRectangles)
+    {
+        local_pDiscardRectangles = (VkRect2D*)pool->alloc(((discardRectangleCount)) * sizeof(const VkRect2D));
+        for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
+        {
+            deepcopy_VkRect2D(pool, pDiscardRectangles + i, (VkRect2D*)(local_pDiscardRectangles + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1350;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1350, 1);
+        countingStream->write((uint64_t*)&cgen_var_1350, 1 * 8);
+        countingStream->write((uint32_t*)&local_firstDiscardRectangle, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_discardRectangleCount, sizeof(uint32_t));
+        for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
+        {
+            marshal_VkRect2D(countingStream, (VkRect2D*)(local_pDiscardRectangles + i));
+        }
+    }
+    uint32_t packetSize_vkCmdSetDiscardRectangleEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetDiscardRectangleEXT = OP_vkCmdSetDiscardRectangleEXT;
+    stream->write(&opcode_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1351;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1351, 1);
+    stream->write((uint64_t*)&cgen_var_1351, 1 * 8);
+    stream->write((uint32_t*)&local_firstDiscardRectangle, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_discardRectangleCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
+    {
+        marshal_VkRect2D(stream, (VkRect2D*)(local_pDiscardRectangles + i));
+    }
+}
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void VkEncoder::vkSetHdrMetadataEXT(
+    VkDevice device,
+    uint32_t swapchainCount,
+    const VkSwapchainKHR* pSwapchains,
+    const VkHdrMetadataEXT* pMetadata)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    uint32_t local_swapchainCount;
+    VkSwapchainKHR* local_pSwapchains;
+    VkHdrMetadataEXT* local_pMetadata;
+    local_device = device;
+    local_swapchainCount = swapchainCount;
+    local_pSwapchains = nullptr;
+    if (pSwapchains)
+    {
+        local_pSwapchains = (VkSwapchainKHR*)pool->dupArray(pSwapchains, ((swapchainCount)) * sizeof(const VkSwapchainKHR));
+    }
+    local_pMetadata = nullptr;
+    if (pMetadata)
+    {
+        local_pMetadata = (VkHdrMetadataEXT*)pool->alloc(((swapchainCount)) * sizeof(const VkHdrMetadataEXT));
+        for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+        {
+            deepcopy_VkHdrMetadataEXT(pool, pMetadata + i, (VkHdrMetadataEXT*)(local_pMetadata + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1352;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1352, 1);
+        countingStream->write((uint64_t*)&cgen_var_1352, 1 * 8);
+        countingStream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
+        if (((swapchainCount)))
+        {
+            uint64_t* cgen_var_1353;
+            countingStream->alloc((void**)&cgen_var_1353, ((swapchainCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1353, ((swapchainCount)));
+            countingStream->write((uint64_t*)cgen_var_1353, ((swapchainCount)) * 8);
+        }
+        for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+        {
+            marshal_VkHdrMetadataEXT(countingStream, (VkHdrMetadataEXT*)(local_pMetadata + i));
+        }
+    }
+    uint32_t packetSize_vkSetHdrMetadataEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkSetHdrMetadataEXT = OP_vkSetHdrMetadataEXT;
+    stream->write(&opcode_vkSetHdrMetadataEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkSetHdrMetadataEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1354;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1354, 1);
+    stream->write((uint64_t*)&cgen_var_1354, 1 * 8);
+    stream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
+    if (((swapchainCount)))
+    {
+        uint64_t* cgen_var_1355;
+        stream->alloc((void**)&cgen_var_1355, ((swapchainCount)) * 8);
+        stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1355, ((swapchainCount)));
+        stream->write((uint64_t*)cgen_var_1355, ((swapchainCount)) * 8);
+    }
+    for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+    {
+        marshal_VkHdrMetadataEXT(stream, (VkHdrMetadataEXT*)(local_pMetadata + i));
+    }
+}
+
+#endif
+#ifdef VK_MVK_ios_surface
+VkResult VkEncoder::vkCreateIOSSurfaceMVK(
+    VkInstance instance,
+    const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkIOSSurfaceCreateInfoMVK* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkIOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkIOSSurfaceCreateInfoMVK));
+        deepcopy_VkIOSSurfaceCreateInfoMVK(pool, pCreateInfo, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1356;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1356, 1);
+        countingStream->write((uint64_t*)&cgen_var_1356, 1 * 8);
+        marshal_VkIOSSurfaceCreateInfoMVK(countingStream, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1357 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1357);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1358;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1358, 1);
+        countingStream->write((uint64_t*)&cgen_var_1358, 8);
+    }
+    uint32_t packetSize_vkCreateIOSSurfaceMVK = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateIOSSurfaceMVK = OP_vkCreateIOSSurfaceMVK;
+    stream->write(&opcode_vkCreateIOSSurfaceMVK, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateIOSSurfaceMVK, sizeof(uint32_t));
+    uint64_t cgen_var_1359;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1359, 1);
+    stream->write((uint64_t*)&cgen_var_1359, 1 * 8);
+    marshal_VkIOSSurfaceCreateInfoMVK(stream, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1360 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1360);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1361;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1361, 1);
+    stream->write((uint64_t*)&cgen_var_1361, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_1362;
+    stream->read((uint64_t*)&cgen_var_1362, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1362, (VkSurfaceKHR*)pSurface, 1);
+    VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateIOSSurfaceMVK_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateIOSSurfaceMVK_VkResult_return;
+}
+
+#endif
+#ifdef VK_MVK_macos_surface
+VkResult VkEncoder::vkCreateMacOSSurfaceMVK(
+    VkInstance instance,
+    const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkSurfaceKHR* pSurface)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkMacOSSurfaceCreateInfoMVK* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkMacOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkMacOSSurfaceCreateInfoMVK));
+        deepcopy_VkMacOSSurfaceCreateInfoMVK(pool, pCreateInfo, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1363;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1363, 1);
+        countingStream->write((uint64_t*)&cgen_var_1363, 1 * 8);
+        marshal_VkMacOSSurfaceCreateInfoMVK(countingStream, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1364 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1364);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1365;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1365, 1);
+        countingStream->write((uint64_t*)&cgen_var_1365, 8);
+    }
+    uint32_t packetSize_vkCreateMacOSSurfaceMVK = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateMacOSSurfaceMVK = OP_vkCreateMacOSSurfaceMVK;
+    stream->write(&opcode_vkCreateMacOSSurfaceMVK, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateMacOSSurfaceMVK, sizeof(uint32_t));
+    uint64_t cgen_var_1366;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1366, 1);
+    stream->write((uint64_t*)&cgen_var_1366, 1 * 8);
+    marshal_VkMacOSSurfaceCreateInfoMVK(stream, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1367 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1367);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1368;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1368, 1);
+    stream->write((uint64_t*)&cgen_var_1368, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    uint64_t cgen_var_1369;
+    stream->read((uint64_t*)&cgen_var_1369, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1369, (VkSurfaceKHR*)pSurface, 1);
+    VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateMacOSSurfaceMVK_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateMacOSSurfaceMVK_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+VkResult VkEncoder::vkSetDebugUtilsObjectNameEXT(
+    VkDevice device,
+    const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDebugUtilsObjectNameInfoEXT* local_pNameInfo;
+    local_device = device;
+    local_pNameInfo = nullptr;
+    if (pNameInfo)
+    {
+        local_pNameInfo = (VkDebugUtilsObjectNameInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectNameInfoEXT));
+        deepcopy_VkDebugUtilsObjectNameInfoEXT(pool, pNameInfo, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1370;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1370, 1);
+        countingStream->write((uint64_t*)&cgen_var_1370, 1 * 8);
+        marshal_VkDebugUtilsObjectNameInfoEXT(countingStream, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
+    }
+    uint32_t packetSize_vkSetDebugUtilsObjectNameEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkSetDebugUtilsObjectNameEXT = OP_vkSetDebugUtilsObjectNameEXT;
+    stream->write(&opcode_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1371;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1371, 1);
+    stream->write((uint64_t*)&cgen_var_1371, 1 * 8);
+    marshal_VkDebugUtilsObjectNameInfoEXT(stream, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
+    VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkSetDebugUtilsObjectNameEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkSetDebugUtilsObjectNameEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkSetDebugUtilsObjectTagEXT(
+    VkDevice device,
+    const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkDebugUtilsObjectTagInfoEXT* local_pTagInfo;
+    local_device = device;
+    local_pTagInfo = nullptr;
+    if (pTagInfo)
+    {
+        local_pTagInfo = (VkDebugUtilsObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectTagInfoEXT));
+        deepcopy_VkDebugUtilsObjectTagInfoEXT(pool, pTagInfo, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1372;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1372, 1);
+        countingStream->write((uint64_t*)&cgen_var_1372, 1 * 8);
+        marshal_VkDebugUtilsObjectTagInfoEXT(countingStream, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
+    }
+    uint32_t packetSize_vkSetDebugUtilsObjectTagEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkSetDebugUtilsObjectTagEXT = OP_vkSetDebugUtilsObjectTagEXT;
+    stream->write(&opcode_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1373;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1373, 1);
+    stream->write((uint64_t*)&cgen_var_1373, 1 * 8);
+    marshal_VkDebugUtilsObjectTagInfoEXT(stream, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
+    VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkSetDebugUtilsObjectTagEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkSetDebugUtilsObjectTagEXT_VkResult_return;
+}
+
+void VkEncoder::vkQueueBeginDebugUtilsLabelEXT(
+    VkQueue queue,
+    const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkQueue local_queue;
+    VkDebugUtilsLabelEXT* local_pLabelInfo;
+    local_queue = queue;
+    local_pLabelInfo = nullptr;
+    if (pLabelInfo)
+    {
+        local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
+        deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1374;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1374, 1);
+        countingStream->write((uint64_t*)&cgen_var_1374, 1 * 8);
+        marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+    }
+    uint32_t packetSize_vkQueueBeginDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueBeginDebugUtilsLabelEXT = OP_vkQueueBeginDebugUtilsLabelEXT;
+    stream->write(&opcode_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1375;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1375, 1);
+    stream->write((uint64_t*)&cgen_var_1375, 1 * 8);
+    marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+}
+
+void VkEncoder::vkQueueEndDebugUtilsLabelEXT(
+    VkQueue queue)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkQueue local_queue;
+    local_queue = queue;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1376;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1376, 1);
+        countingStream->write((uint64_t*)&cgen_var_1376, 1 * 8);
+    }
+    uint32_t packetSize_vkQueueEndDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueEndDebugUtilsLabelEXT = OP_vkQueueEndDebugUtilsLabelEXT;
+    stream->write(&opcode_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1377;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1377, 1);
+    stream->write((uint64_t*)&cgen_var_1377, 1 * 8);
+}
+
+void VkEncoder::vkQueueInsertDebugUtilsLabelEXT(
+    VkQueue queue,
+    const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkQueue local_queue;
+    VkDebugUtilsLabelEXT* local_pLabelInfo;
+    local_queue = queue;
+    local_pLabelInfo = nullptr;
+    if (pLabelInfo)
+    {
+        local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
+        deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1378;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1378, 1);
+        countingStream->write((uint64_t*)&cgen_var_1378, 1 * 8);
+        marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+    }
+    uint32_t packetSize_vkQueueInsertDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueInsertDebugUtilsLabelEXT = OP_vkQueueInsertDebugUtilsLabelEXT;
+    stream->write(&opcode_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1379;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1379, 1);
+    stream->write((uint64_t*)&cgen_var_1379, 1 * 8);
+    marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+}
+
+void VkEncoder::vkCmdBeginDebugUtilsLabelEXT(
+    VkCommandBuffer commandBuffer,
+    const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkDebugUtilsLabelEXT* local_pLabelInfo;
+    local_commandBuffer = commandBuffer;
+    local_pLabelInfo = nullptr;
+    if (pLabelInfo)
+    {
+        local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
+        deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1380;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1380, 1);
+        countingStream->write((uint64_t*)&cgen_var_1380, 1 * 8);
+        marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+    }
+    uint32_t packetSize_vkCmdBeginDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdBeginDebugUtilsLabelEXT = OP_vkCmdBeginDebugUtilsLabelEXT;
+    stream->write(&opcode_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1381;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1381, 1);
+    stream->write((uint64_t*)&cgen_var_1381, 1 * 8);
+    marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+}
+
+void VkEncoder::vkCmdEndDebugUtilsLabelEXT(
+    VkCommandBuffer commandBuffer)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    local_commandBuffer = commandBuffer;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1382;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1382, 1);
+        countingStream->write((uint64_t*)&cgen_var_1382, 1 * 8);
+    }
+    uint32_t packetSize_vkCmdEndDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdEndDebugUtilsLabelEXT = OP_vkCmdEndDebugUtilsLabelEXT;
+    stream->write(&opcode_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1383;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1383, 1);
+    stream->write((uint64_t*)&cgen_var_1383, 1 * 8);
+}
+
+void VkEncoder::vkCmdInsertDebugUtilsLabelEXT(
+    VkCommandBuffer commandBuffer,
+    const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkDebugUtilsLabelEXT* local_pLabelInfo;
+    local_commandBuffer = commandBuffer;
+    local_pLabelInfo = nullptr;
+    if (pLabelInfo)
+    {
+        local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
+        deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1384;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1384, 1);
+        countingStream->write((uint64_t*)&cgen_var_1384, 1 * 8);
+        marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+    }
+    uint32_t packetSize_vkCmdInsertDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdInsertDebugUtilsLabelEXT = OP_vkCmdInsertDebugUtilsLabelEXT;
+    stream->write(&opcode_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1385;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1385, 1);
+    stream->write((uint64_t*)&cgen_var_1385, 1 * 8);
+    marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+}
+
+VkResult VkEncoder::vkCreateDebugUtilsMessengerEXT(
+    VkInstance instance,
+    const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDebugUtilsMessengerEXT* pMessenger)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkDebugUtilsMessengerCreateInfoEXT* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkDebugUtilsMessengerCreateInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsMessengerCreateInfoEXT));
+        deepcopy_VkDebugUtilsMessengerCreateInfoEXT(pool, pCreateInfo, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1386;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1386, 1);
+        countingStream->write((uint64_t*)&cgen_var_1386, 1 * 8);
+        marshal_VkDebugUtilsMessengerCreateInfoEXT(countingStream, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1387 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1387);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1388;
+        countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1388, 1);
+        countingStream->write((uint64_t*)&cgen_var_1388, 8);
+    }
+    uint32_t packetSize_vkCreateDebugUtilsMessengerEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateDebugUtilsMessengerEXT = OP_vkCreateDebugUtilsMessengerEXT;
+    stream->write(&opcode_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1389;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1389, 1);
+    stream->write((uint64_t*)&cgen_var_1389, 1 * 8);
+    marshal_VkDebugUtilsMessengerCreateInfoEXT(stream, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1390 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1390);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1391;
+    stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1391, 1);
+    stream->write((uint64_t*)&cgen_var_1391, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_1392;
+    stream->read((uint64_t*)&cgen_var_1392, 8);
+    stream->handleMapping()->mapHandles_u64_VkDebugUtilsMessengerEXT(&cgen_var_1392, (VkDebugUtilsMessengerEXT*)pMessenger, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateDebugUtilsMessengerEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateDebugUtilsMessengerEXT_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDebugUtilsMessengerEXT(
+    VkInstance instance,
+    VkDebugUtilsMessengerEXT messenger,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkDebugUtilsMessengerEXT local_messenger;
+    VkAllocationCallbacks* local_pAllocator;
+    local_instance = instance;
+    local_messenger = messenger;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1393;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1393, 1);
+        countingStream->write((uint64_t*)&cgen_var_1393, 1 * 8);
+        uint64_t cgen_var_1394;
+        countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1394, 1);
+        countingStream->write((uint64_t*)&cgen_var_1394, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1395 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1395);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyDebugUtilsMessengerEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyDebugUtilsMessengerEXT = OP_vkDestroyDebugUtilsMessengerEXT;
+    stream->write(&opcode_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1396;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1396, 1);
+    stream->write((uint64_t*)&cgen_var_1396, 1 * 8);
+    uint64_t cgen_var_1397;
+    stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1397, 1);
+    stream->write((uint64_t*)&cgen_var_1397, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1398 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1398);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkDebugUtilsMessengerEXT((VkDebugUtilsMessengerEXT*)&messenger);
+}
+
+void VkEncoder::vkSubmitDebugUtilsMessageEXT(
+    VkInstance instance,
+    VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+    VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkInstance local_instance;
+    VkDebugUtilsMessageSeverityFlagBitsEXT local_messageSeverity;
+    VkDebugUtilsMessageTypeFlagsEXT local_messageTypes;
+    VkDebugUtilsMessengerCallbackDataEXT* local_pCallbackData;
+    local_instance = instance;
+    local_messageSeverity = messageSeverity;
+    local_messageTypes = messageTypes;
+    local_pCallbackData = nullptr;
+    if (pCallbackData)
+    {
+        local_pCallbackData = (VkDebugUtilsMessengerCallbackDataEXT*)pool->alloc(sizeof(const VkDebugUtilsMessengerCallbackDataEXT));
+        deepcopy_VkDebugUtilsMessengerCallbackDataEXT(pool, pCallbackData, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1399;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1399, 1);
+        countingStream->write((uint64_t*)&cgen_var_1399, 1 * 8);
+        countingStream->write((VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
+        countingStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+        marshal_VkDebugUtilsMessengerCallbackDataEXT(countingStream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
+    }
+    uint32_t packetSize_vkSubmitDebugUtilsMessageEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkSubmitDebugUtilsMessageEXT = OP_vkSubmitDebugUtilsMessageEXT;
+    stream->write(&opcode_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1400;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1400, 1);
+    stream->write((uint64_t*)&cgen_var_1400, 1 * 8);
+    stream->write((VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
+    stream->write((VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+    marshal_VkDebugUtilsMessengerCallbackDataEXT(stream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
+}
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+VkResult VkEncoder::vkGetAndroidHardwareBufferPropertiesANDROID(
+    VkDevice device,
+    const AHardwareBuffer* buffer,
+    VkAndroidHardwareBufferPropertiesANDROID* pProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    AHardwareBuffer* local_buffer;
+    local_device = device;
+    local_buffer = nullptr;
+    if (buffer)
+    {
+        local_buffer = (AHardwareBuffer*)pool->dupArray(buffer, sizeof(const AHardwareBuffer));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1401;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1401, 1);
+        countingStream->write((uint64_t*)&cgen_var_1401, 1 * 8);
+        countingStream->write((AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
+        marshal_VkAndroidHardwareBufferPropertiesANDROID(countingStream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
+    }
+    uint32_t packetSize_vkGetAndroidHardwareBufferPropertiesANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetAndroidHardwareBufferPropertiesANDROID = OP_vkGetAndroidHardwareBufferPropertiesANDROID;
+    stream->write(&opcode_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t));
+    uint64_t cgen_var_1402;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1402, 1);
+    stream->write((uint64_t*)&cgen_var_1402, 1 * 8);
+    stream->write((AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
+    marshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
+    unmarshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
+    VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
+    stream->read(&vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetMemoryAndroidHardwareBufferANDROID(
+    VkDevice device,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+    AHardwareBuffer** pBuffer)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkMemoryGetAndroidHardwareBufferInfoANDROID* local_pInfo;
+    local_device = device;
+    local_pInfo = nullptr;
+    if (pInfo)
+    {
+        local_pInfo = (VkMemoryGetAndroidHardwareBufferInfoANDROID*)pool->alloc(sizeof(const VkMemoryGetAndroidHardwareBufferInfoANDROID));
+        deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(pool, pInfo, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1403;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1403, 1);
+        countingStream->write((uint64_t*)&cgen_var_1403, 1 * 8);
+        marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(countingStream, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
+        countingStream->write((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
+    }
+    uint32_t packetSize_vkGetMemoryAndroidHardwareBufferANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetMemoryAndroidHardwareBufferANDROID = OP_vkGetMemoryAndroidHardwareBufferANDROID;
+    stream->write(&opcode_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t));
+    uint64_t cgen_var_1404;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1404, 1);
+    stream->write((uint64_t*)&cgen_var_1404, 1 * 8);
+    marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(stream, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
+    stream->write((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
+    stream->read((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
+    VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
+    stream->read(&vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void VkEncoder::vkCmdSetSampleLocationsEXT(
+    VkCommandBuffer commandBuffer,
+    const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkSampleLocationsInfoEXT* local_pSampleLocationsInfo;
+    local_commandBuffer = commandBuffer;
+    local_pSampleLocationsInfo = nullptr;
+    if (pSampleLocationsInfo)
+    {
+        local_pSampleLocationsInfo = (VkSampleLocationsInfoEXT*)pool->alloc(sizeof(const VkSampleLocationsInfoEXT));
+        deepcopy_VkSampleLocationsInfoEXT(pool, pSampleLocationsInfo, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1405;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1405, 1);
+        countingStream->write((uint64_t*)&cgen_var_1405, 1 * 8);
+        marshal_VkSampleLocationsInfoEXT(countingStream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
+    }
+    uint32_t packetSize_vkCmdSetSampleLocationsEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetSampleLocationsEXT = OP_vkCmdSetSampleLocationsEXT;
+    stream->write(&opcode_vkCmdSetSampleLocationsEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetSampleLocationsEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1406;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1406, 1);
+    stream->write((uint64_t*)&cgen_var_1406, 1 * 8);
+    marshal_VkSampleLocationsInfoEXT(stream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
+}
+
+void VkEncoder::vkGetPhysicalDeviceMultisamplePropertiesEXT(
+    VkPhysicalDevice physicalDevice,
+    VkSampleCountFlagBits samples,
+    VkMultisamplePropertiesEXT* pMultisampleProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    VkSampleCountFlagBits local_samples;
+    local_physicalDevice = physicalDevice;
+    local_samples = samples;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1407;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1407, 1);
+        countingStream->write((uint64_t*)&cgen_var_1407, 1 * 8);
+        countingStream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
+        marshal_VkMultisamplePropertiesEXT(countingStream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT = OP_vkGetPhysicalDeviceMultisamplePropertiesEXT;
+    stream->write(&opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1408;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1408, 1);
+    stream->write((uint64_t*)&cgen_var_1408, 1 * 8);
+    stream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
+    marshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
+    unmarshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
+}
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+VkResult VkEncoder::vkCreateValidationCacheEXT(
+    VkDevice device,
+    const VkValidationCacheCreateInfoEXT* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkValidationCacheEXT* pValidationCache)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkValidationCacheCreateInfoEXT* local_pCreateInfo;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_pCreateInfo = nullptr;
+    if (pCreateInfo)
+    {
+        local_pCreateInfo = (VkValidationCacheCreateInfoEXT*)pool->alloc(sizeof(const VkValidationCacheCreateInfoEXT));
+        deepcopy_VkValidationCacheCreateInfoEXT(pool, pCreateInfo, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
+    }
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1409;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1409, 1);
+        countingStream->write((uint64_t*)&cgen_var_1409, 1 * 8);
+        marshal_VkValidationCacheCreateInfoEXT(countingStream, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1410 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1410);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+        uint64_t cgen_var_1411;
+        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1411, 1);
+        countingStream->write((uint64_t*)&cgen_var_1411, 8);
+    }
+    uint32_t packetSize_vkCreateValidationCacheEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCreateValidationCacheEXT = OP_vkCreateValidationCacheEXT;
+    stream->write(&opcode_vkCreateValidationCacheEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkCreateValidationCacheEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1412;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1412, 1);
+    stream->write((uint64_t*)&cgen_var_1412, 1 * 8);
+    marshal_VkValidationCacheCreateInfoEXT(stream, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1413 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1413);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+    uint64_t cgen_var_1414;
+    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1414, 1);
+    stream->write((uint64_t*)&cgen_var_1414, 8);
+    stream->setHandleMapping(resources->unwrapMapping());
+    stream->setHandleMapping(resources->createMapping());
+    uint64_t cgen_var_1415;
+    stream->read((uint64_t*)&cgen_var_1415, 8);
+    stream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_1415, (VkValidationCacheEXT*)pValidationCache, 1);
+    stream->unsetHandleMapping();
+    VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkCreateValidationCacheEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkCreateValidationCacheEXT_VkResult_return;
+}
+
+void VkEncoder::vkDestroyValidationCacheEXT(
+    VkDevice device,
+    VkValidationCacheEXT validationCache,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkValidationCacheEXT local_validationCache;
+    VkAllocationCallbacks* local_pAllocator;
+    local_device = device;
+    local_validationCache = validationCache;
+    local_pAllocator = nullptr;
+    if (pAllocator)
+    {
+        local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+        deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    local_pAllocator = nullptr;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1416;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1416, 1);
+        countingStream->write((uint64_t*)&cgen_var_1416, 1 * 8);
+        uint64_t cgen_var_1417;
+        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1417, 1);
+        countingStream->write((uint64_t*)&cgen_var_1417, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1418 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1418);
+        if (local_pAllocator)
+        {
+            marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+        }
+    }
+    uint32_t packetSize_vkDestroyValidationCacheEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkDestroyValidationCacheEXT = OP_vkDestroyValidationCacheEXT;
+    stream->write(&opcode_vkDestroyValidationCacheEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkDestroyValidationCacheEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1419;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1419, 1);
+    stream->write((uint64_t*)&cgen_var_1419, 1 * 8);
+    uint64_t cgen_var_1420;
+    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1420, 1);
+    stream->write((uint64_t*)&cgen_var_1420, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1421 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1421);
+    if (local_pAllocator)
+    {
+        marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+    }
+    resources->destroyMapping()->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&validationCache);
+}
+
+VkResult VkEncoder::vkMergeValidationCachesEXT(
+    VkDevice device,
+    VkValidationCacheEXT dstCache,
+    uint32_t srcCacheCount,
+    const VkValidationCacheEXT* pSrcCaches)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkValidationCacheEXT local_dstCache;
+    uint32_t local_srcCacheCount;
+    VkValidationCacheEXT* local_pSrcCaches;
+    local_device = device;
+    local_dstCache = dstCache;
+    local_srcCacheCount = srcCacheCount;
+    local_pSrcCaches = nullptr;
+    if (pSrcCaches)
+    {
+        local_pSrcCaches = (VkValidationCacheEXT*)pool->dupArray(pSrcCaches, ((srcCacheCount)) * sizeof(const VkValidationCacheEXT));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1422;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1422, 1);
+        countingStream->write((uint64_t*)&cgen_var_1422, 1 * 8);
+        uint64_t cgen_var_1423;
+        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1423, 1);
+        countingStream->write((uint64_t*)&cgen_var_1423, 1 * 8);
+        countingStream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
+        if (((srcCacheCount)))
+        {
+            uint64_t* cgen_var_1424;
+            countingStream->alloc((void**)&cgen_var_1424, ((srcCacheCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1424, ((srcCacheCount)));
+            countingStream->write((uint64_t*)cgen_var_1424, ((srcCacheCount)) * 8);
+        }
+    }
+    uint32_t packetSize_vkMergeValidationCachesEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkMergeValidationCachesEXT = OP_vkMergeValidationCachesEXT;
+    stream->write(&opcode_vkMergeValidationCachesEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkMergeValidationCachesEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1425;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1425, 1);
+    stream->write((uint64_t*)&cgen_var_1425, 1 * 8);
+    uint64_t cgen_var_1426;
+    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1426, 1);
+    stream->write((uint64_t*)&cgen_var_1426, 1 * 8);
+    stream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
+    if (((srcCacheCount)))
+    {
+        uint64_t* cgen_var_1427;
+        stream->alloc((void**)&cgen_var_1427, ((srcCacheCount)) * 8);
+        stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1427, ((srcCacheCount)));
+        stream->write((uint64_t*)cgen_var_1427, ((srcCacheCount)) * 8);
+    }
+    VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkMergeValidationCachesEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkMergeValidationCachesEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetValidationCacheDataEXT(
+    VkDevice device,
+    VkValidationCacheEXT validationCache,
+    size_t* pDataSize,
+    void* pData)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkValidationCacheEXT local_validationCache;
+    local_device = device;
+    local_validationCache = validationCache;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1428;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1428, 1);
+        countingStream->write((uint64_t*)&cgen_var_1428, 1 * 8);
+        uint64_t cgen_var_1429;
+        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1429, 1);
+        countingStream->write((uint64_t*)&cgen_var_1429, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1430 = (uint64_t)(uintptr_t)pDataSize;
+        countingStream->putBe64(cgen_var_1430);
+        if (pDataSize)
+        {
+            uint64_t cgen_var_1431 = (uint64_t)(*pDataSize);
+            countingStream->putBe64(cgen_var_1431);
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1432 = (uint64_t)(uintptr_t)pData;
+        countingStream->putBe64(cgen_var_1432);
+        if (pData)
+        {
+            countingStream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+        }
+    }
+    uint32_t packetSize_vkGetValidationCacheDataEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetValidationCacheDataEXT = OP_vkGetValidationCacheDataEXT;
+    stream->write(&opcode_vkGetValidationCacheDataEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetValidationCacheDataEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1433;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1433, 1);
+    stream->write((uint64_t*)&cgen_var_1433, 1 * 8);
+    uint64_t cgen_var_1434;
+    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1434, 1);
+    stream->write((uint64_t*)&cgen_var_1434, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1435 = (uint64_t)(uintptr_t)pDataSize;
+    stream->putBe64(cgen_var_1435);
+    if (pDataSize)
+    {
+        uint64_t cgen_var_1436 = (uint64_t)(*pDataSize);
+        stream->putBe64(cgen_var_1436);
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1437 = (uint64_t)(uintptr_t)pData;
+    stream->putBe64(cgen_var_1437);
+    if (pData)
+    {
+        stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+    }
+    // WARNING PTR CHECK
+    size_t* check_pDataSize;
+    check_pDataSize = (size_t*)(uintptr_t)stream->getBe64();
+    if (pDataSize)
+    {
+        if (!(check_pDataSize))
+        {
+            fprintf(stderr, "fatal: pDataSize inconsistent between guest and host\n");
+        }
+        (*pDataSize) = (size_t)stream->getBe64();
+    }
+    // WARNING PTR CHECK
+    void* check_pData;
+    check_pData = (void*)(uintptr_t)stream->getBe64();
+    if (pData)
+    {
+        if (!(check_pData))
+        {
+            fprintf(stderr, "fatal: pData inconsistent between guest and host\n");
+        }
+        stream->read((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+    }
+    VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkGetValidationCacheDataEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetValidationCacheDataEXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+VkResult VkEncoder::vkGetMemoryHostPointerPropertiesEXT(
+    VkDevice device,
+    VkExternalMemoryHandleTypeFlagBits handleType,
+    const void* pHostPointer,
+    VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkExternalMemoryHandleTypeFlagBits local_handleType;
+    void* local_pHostPointer;
+    local_device = device;
+    local_handleType = handleType;
+    local_pHostPointer = nullptr;
+    if (pHostPointer)
+    {
+        local_pHostPointer = (void*)pool->dupArray(pHostPointer, sizeof(const uint8_t));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1441;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1441, 1);
+        countingStream->write((uint64_t*)&cgen_var_1441, 1 * 8);
+        countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1442 = (uint64_t)(uintptr_t)local_pHostPointer;
+        countingStream->putBe64(cgen_var_1442);
+        if (local_pHostPointer)
+        {
+            countingStream->write((void*)local_pHostPointer, sizeof(uint8_t));
+        }
+        marshal_VkMemoryHostPointerPropertiesEXT(countingStream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+    }
+    uint32_t packetSize_vkGetMemoryHostPointerPropertiesEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetMemoryHostPointerPropertiesEXT = OP_vkGetMemoryHostPointerPropertiesEXT;
+    stream->write(&opcode_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t));
+    uint64_t cgen_var_1443;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1443, 1);
+    stream->write((uint64_t*)&cgen_var_1443, 1 * 8);
+    stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1444 = (uint64_t)(uintptr_t)local_pHostPointer;
+    stream->putBe64(cgen_var_1444);
+    if (local_pHostPointer)
+    {
+        stream->write((void*)local_pHostPointer, sizeof(uint8_t));
+    }
+    marshal_VkMemoryHostPointerPropertiesEXT(stream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+    unmarshal_VkMemoryHostPointerPropertiesEXT(stream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+    VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
+    stream->read(&vkGetMemoryHostPointerPropertiesEXT_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
+    return vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_AMD_buffer_marker
+void VkEncoder::vkCmdWriteBufferMarkerAMD(
+    VkCommandBuffer commandBuffer,
+    VkPipelineStageFlagBits pipelineStage,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
+    uint32_t marker)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    VkPipelineStageFlagBits local_pipelineStage;
+    VkBuffer local_dstBuffer;
+    VkDeviceSize local_dstOffset;
+    uint32_t local_marker;
+    local_commandBuffer = commandBuffer;
+    local_pipelineStage = pipelineStage;
+    local_dstBuffer = dstBuffer;
+    local_dstOffset = dstOffset;
+    local_marker = marker;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1445;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1445, 1);
+        countingStream->write((uint64_t*)&cgen_var_1445, 1 * 8);
+        countingStream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
+        uint64_t cgen_var_1446;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1446, 1);
+        countingStream->write((uint64_t*)&cgen_var_1446, 1 * 8);
+        countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+        countingStream->write((uint32_t*)&local_marker, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkCmdWriteBufferMarkerAMD = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdWriteBufferMarkerAMD = OP_vkCmdWriteBufferMarkerAMD;
+    stream->write(&opcode_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t));
+    uint64_t cgen_var_1447;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1447, 1);
+    stream->write((uint64_t*)&cgen_var_1447, 1 * 8);
+    stream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
+    uint64_t cgen_var_1448;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1448, 1);
+    stream->write((uint64_t*)&cgen_var_1448, 1 * 8);
+    stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+    stream->write((uint32_t*)&local_marker, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void VkEncoder::vkCmdSetCheckpointNV(
+    VkCommandBuffer commandBuffer,
+    const void* pCheckpointMarker)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkCommandBuffer local_commandBuffer;
+    void* local_pCheckpointMarker;
+    local_commandBuffer = commandBuffer;
+    local_pCheckpointMarker = nullptr;
+    if (pCheckpointMarker)
+    {
+        local_pCheckpointMarker = (void*)pool->dupArray(pCheckpointMarker, sizeof(const uint8_t));
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1449;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1449, 1);
+        countingStream->write((uint64_t*)&cgen_var_1449, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1450 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
+        countingStream->putBe64(cgen_var_1450);
+        if (local_pCheckpointMarker)
+        {
+            countingStream->write((void*)local_pCheckpointMarker, sizeof(uint8_t));
+        }
+    }
+    uint32_t packetSize_vkCmdSetCheckpointNV = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkCmdSetCheckpointNV = OP_vkCmdSetCheckpointNV;
+    stream->write(&opcode_vkCmdSetCheckpointNV, sizeof(uint32_t));
+    stream->write(&packetSize_vkCmdSetCheckpointNV, sizeof(uint32_t));
+    uint64_t cgen_var_1451;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1451, 1);
+    stream->write((uint64_t*)&cgen_var_1451, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1452 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
+    stream->putBe64(cgen_var_1452);
+    if (local_pCheckpointMarker)
+    {
+        stream->write((void*)local_pCheckpointMarker, sizeof(uint8_t));
+    }
+}
+
+void VkEncoder::vkGetQueueCheckpointDataNV(
+    VkQueue queue,
+    uint32_t* pCheckpointDataCount,
+    VkCheckpointDataNV* pCheckpointData)
+{
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkQueue local_queue;
+    local_queue = queue;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1453;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1453, 1);
+        countingStream->write((uint64_t*)&cgen_var_1453, 1 * 8);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1454 = (uint64_t)(uintptr_t)pCheckpointDataCount;
+        countingStream->putBe64(cgen_var_1454);
+        if (pCheckpointDataCount)
+        {
+            countingStream->write((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_1455 = (uint64_t)(uintptr_t)pCheckpointData;
+        countingStream->putBe64(cgen_var_1455);
+        if (pCheckpointData)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
+            {
+                marshal_VkCheckpointDataNV(countingStream, (VkCheckpointDataNV*)(pCheckpointData + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkGetQueueCheckpointDataNV = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetQueueCheckpointDataNV = OP_vkGetQueueCheckpointDataNV;
+    stream->write(&opcode_vkGetQueueCheckpointDataNV, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetQueueCheckpointDataNV, sizeof(uint32_t));
+    uint64_t cgen_var_1456;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1456, 1);
+    stream->write((uint64_t*)&cgen_var_1456, 1 * 8);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1457 = (uint64_t)(uintptr_t)pCheckpointDataCount;
+    stream->putBe64(cgen_var_1457);
+    if (pCheckpointDataCount)
+    {
+        stream->write((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1458 = (uint64_t)(uintptr_t)pCheckpointData;
+    stream->putBe64(cgen_var_1458);
+    if (pCheckpointData)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
+        {
+            marshal_VkCheckpointDataNV(stream, (VkCheckpointDataNV*)(pCheckpointData + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pCheckpointDataCount;
+    check_pCheckpointDataCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pCheckpointDataCount)
+    {
+        if (!(check_pCheckpointDataCount))
+        {
+            fprintf(stderr, "fatal: pCheckpointDataCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkCheckpointDataNV* check_pCheckpointData;
+    check_pCheckpointData = (VkCheckpointDataNV*)(uintptr_t)stream->getBe64();
+    if (pCheckpointData)
+    {
+        if (!(check_pCheckpointData))
+        {
+            fprintf(stderr, "fatal: pCheckpointData inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
+        {
+            unmarshal_VkCheckpointDataNV(stream, (VkCheckpointDataNV*)(pCheckpointData + i));
+        }
+    }
+}
+
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEncoder.h b/system/vulkan_enc/VkEncoder.h
new file mode 100644
index 0000000..2eacb67
--- /dev/null
+++ b/system/vulkan_enc/VkEncoder.h
@@ -0,0 +1,1750 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module VkEncoder
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "goldfish_vk_private_defs.h"
+#include <memory>
+class IOStream;
+
+
+namespace goldfish_vk {
+
+
+class VkEncoder {
+public:
+    VkEncoder(IOStream* stream);
+    ~VkEncoder();
+#ifdef VK_VERSION_1_0
+    VkResult vkCreateInstance(
+    const VkInstanceCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkInstance* pInstance);
+    void vkDestroyInstance(
+    VkInstance instance,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkEnumeratePhysicalDevices(
+    VkInstance instance,
+        uint32_t* pPhysicalDeviceCount,
+        VkPhysicalDevice* pPhysicalDevices);
+    void vkGetPhysicalDeviceFeatures(
+    VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceFeatures* pFeatures);
+    void vkGetPhysicalDeviceFormatProperties(
+    VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkFormatProperties* pFormatProperties);
+    VkResult vkGetPhysicalDeviceImageFormatProperties(
+    VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkImageType type,
+        VkImageTiling tiling,
+        VkImageUsageFlags usage,
+        VkImageCreateFlags flags,
+        VkImageFormatProperties* pImageFormatProperties);
+    void vkGetPhysicalDeviceProperties(
+    VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceProperties* pProperties);
+    void vkGetPhysicalDeviceQueueFamilyProperties(
+    VkPhysicalDevice physicalDevice,
+        uint32_t* pQueueFamilyPropertyCount,
+        VkQueueFamilyProperties* pQueueFamilyProperties);
+    void vkGetPhysicalDeviceMemoryProperties(
+    VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+    PFN_vkVoidFunction vkGetInstanceProcAddr(
+    VkInstance instance,
+        const char* pName);
+    PFN_vkVoidFunction vkGetDeviceProcAddr(
+    VkDevice device,
+        const char* pName);
+    VkResult vkCreateDevice(
+    VkPhysicalDevice physicalDevice,
+        const VkDeviceCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDevice* pDevice);
+    void vkDestroyDevice(
+    VkDevice device,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkEnumerateInstanceExtensionProperties(
+    const char* pLayerName,
+        uint32_t* pPropertyCount,
+        VkExtensionProperties* pProperties);
+    VkResult vkEnumerateDeviceExtensionProperties(
+    VkPhysicalDevice physicalDevice,
+        const char* pLayerName,
+        uint32_t* pPropertyCount,
+        VkExtensionProperties* pProperties);
+    VkResult vkEnumerateInstanceLayerProperties(
+    uint32_t* pPropertyCount,
+        VkLayerProperties* pProperties);
+    VkResult vkEnumerateDeviceLayerProperties(
+    VkPhysicalDevice physicalDevice,
+        uint32_t* pPropertyCount,
+        VkLayerProperties* pProperties);
+    void vkGetDeviceQueue(
+    VkDevice device,
+        uint32_t queueFamilyIndex,
+        uint32_t queueIndex,
+        VkQueue* pQueue);
+    VkResult vkQueueSubmit(
+    VkQueue queue,
+        uint32_t submitCount,
+        const VkSubmitInfo* pSubmits,
+        VkFence fence);
+    VkResult vkQueueWaitIdle(
+    VkQueue queue);
+    VkResult vkDeviceWaitIdle(
+    VkDevice device);
+    VkResult vkAllocateMemory(
+    VkDevice device,
+        const VkMemoryAllocateInfo* pAllocateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDeviceMemory* pMemory);
+    void vkFreeMemory(
+    VkDevice device,
+        VkDeviceMemory memory,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkMapMemory(
+    VkDevice device,
+        VkDeviceMemory memory,
+        VkDeviceSize offset,
+        VkDeviceSize size,
+        VkMemoryMapFlags flags,
+        void** ppData);
+    void vkUnmapMemory(
+    VkDevice device,
+        VkDeviceMemory memory);
+    VkResult vkFlushMappedMemoryRanges(
+    VkDevice device,
+        uint32_t memoryRangeCount,
+        const VkMappedMemoryRange* pMemoryRanges);
+    VkResult vkInvalidateMappedMemoryRanges(
+    VkDevice device,
+        uint32_t memoryRangeCount,
+        const VkMappedMemoryRange* pMemoryRanges);
+    void vkGetDeviceMemoryCommitment(
+    VkDevice device,
+        VkDeviceMemory memory,
+        VkDeviceSize* pCommittedMemoryInBytes);
+    VkResult vkBindBufferMemory(
+    VkDevice device,
+        VkBuffer buffer,
+        VkDeviceMemory memory,
+        VkDeviceSize memoryOffset);
+    VkResult vkBindImageMemory(
+    VkDevice device,
+        VkImage image,
+        VkDeviceMemory memory,
+        VkDeviceSize memoryOffset);
+    void vkGetBufferMemoryRequirements(
+    VkDevice device,
+        VkBuffer buffer,
+        VkMemoryRequirements* pMemoryRequirements);
+    void vkGetImageMemoryRequirements(
+    VkDevice device,
+        VkImage image,
+        VkMemoryRequirements* pMemoryRequirements);
+    void vkGetImageSparseMemoryRequirements(
+    VkDevice device,
+        VkImage image,
+        uint32_t* pSparseMemoryRequirementCount,
+        VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+    void vkGetPhysicalDeviceSparseImageFormatProperties(
+    VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkImageType type,
+        VkSampleCountFlagBits samples,
+        VkImageUsageFlags usage,
+        VkImageTiling tiling,
+        uint32_t* pPropertyCount,
+        VkSparseImageFormatProperties* pProperties);
+    VkResult vkQueueBindSparse(
+    VkQueue queue,
+        uint32_t bindInfoCount,
+        const VkBindSparseInfo* pBindInfo,
+        VkFence fence);
+    VkResult vkCreateFence(
+    VkDevice device,
+        const VkFenceCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkFence* pFence);
+    void vkDestroyFence(
+    VkDevice device,
+        VkFence fence,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkResetFences(
+    VkDevice device,
+        uint32_t fenceCount,
+        const VkFence* pFences);
+    VkResult vkGetFenceStatus(
+    VkDevice device,
+        VkFence fence);
+    VkResult vkWaitForFences(
+    VkDevice device,
+        uint32_t fenceCount,
+        const VkFence* pFences,
+        VkBool32 waitAll,
+        uint64_t timeout);
+    VkResult vkCreateSemaphore(
+    VkDevice device,
+        const VkSemaphoreCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSemaphore* pSemaphore);
+    void vkDestroySemaphore(
+    VkDevice device,
+        VkSemaphore semaphore,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreateEvent(
+    VkDevice device,
+        const VkEventCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkEvent* pEvent);
+    void vkDestroyEvent(
+    VkDevice device,
+        VkEvent event,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkGetEventStatus(
+    VkDevice device,
+        VkEvent event);
+    VkResult vkSetEvent(
+    VkDevice device,
+        VkEvent event);
+    VkResult vkResetEvent(
+    VkDevice device,
+        VkEvent event);
+    VkResult vkCreateQueryPool(
+    VkDevice device,
+        const VkQueryPoolCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkQueryPool* pQueryPool);
+    void vkDestroyQueryPool(
+    VkDevice device,
+        VkQueryPool queryPool,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkGetQueryPoolResults(
+    VkDevice device,
+        VkQueryPool queryPool,
+        uint32_t firstQuery,
+        uint32_t queryCount,
+        size_t dataSize,
+        void* pData,
+        VkDeviceSize stride,
+        VkQueryResultFlags flags);
+    VkResult vkCreateBuffer(
+    VkDevice device,
+        const VkBufferCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkBuffer* pBuffer);
+    void vkDestroyBuffer(
+    VkDevice device,
+        VkBuffer buffer,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreateBufferView(
+    VkDevice device,
+        const VkBufferViewCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkBufferView* pView);
+    void vkDestroyBufferView(
+    VkDevice device,
+        VkBufferView bufferView,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreateImage(
+    VkDevice device,
+        const VkImageCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkImage* pImage);
+    void vkDestroyImage(
+    VkDevice device,
+        VkImage image,
+        const VkAllocationCallbacks* pAllocator);
+    void vkGetImageSubresourceLayout(
+    VkDevice device,
+        VkImage image,
+        const VkImageSubresource* pSubresource,
+        VkSubresourceLayout* pLayout);
+    VkResult vkCreateImageView(
+    VkDevice device,
+        const VkImageViewCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkImageView* pView);
+    void vkDestroyImageView(
+    VkDevice device,
+        VkImageView imageView,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreateShaderModule(
+    VkDevice device,
+        const VkShaderModuleCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkShaderModule* pShaderModule);
+    void vkDestroyShaderModule(
+    VkDevice device,
+        VkShaderModule shaderModule,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreatePipelineCache(
+    VkDevice device,
+        const VkPipelineCacheCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkPipelineCache* pPipelineCache);
+    void vkDestroyPipelineCache(
+    VkDevice device,
+        VkPipelineCache pipelineCache,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkGetPipelineCacheData(
+    VkDevice device,
+        VkPipelineCache pipelineCache,
+        size_t* pDataSize,
+        void* pData);
+    VkResult vkMergePipelineCaches(
+    VkDevice device,
+        VkPipelineCache dstCache,
+        uint32_t srcCacheCount,
+        const VkPipelineCache* pSrcCaches);
+    VkResult vkCreateGraphicsPipelines(
+    VkDevice device,
+        VkPipelineCache pipelineCache,
+        uint32_t createInfoCount,
+        const VkGraphicsPipelineCreateInfo* pCreateInfos,
+        const VkAllocationCallbacks* pAllocator,
+        VkPipeline* pPipelines);
+    VkResult vkCreateComputePipelines(
+    VkDevice device,
+        VkPipelineCache pipelineCache,
+        uint32_t createInfoCount,
+        const VkComputePipelineCreateInfo* pCreateInfos,
+        const VkAllocationCallbacks* pAllocator,
+        VkPipeline* pPipelines);
+    void vkDestroyPipeline(
+    VkDevice device,
+        VkPipeline pipeline,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreatePipelineLayout(
+    VkDevice device,
+        const VkPipelineLayoutCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkPipelineLayout* pPipelineLayout);
+    void vkDestroyPipelineLayout(
+    VkDevice device,
+        VkPipelineLayout pipelineLayout,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreateSampler(
+    VkDevice device,
+        const VkSamplerCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSampler* pSampler);
+    void vkDestroySampler(
+    VkDevice device,
+        VkSampler sampler,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreateDescriptorSetLayout(
+    VkDevice device,
+        const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDescriptorSetLayout* pSetLayout);
+    void vkDestroyDescriptorSetLayout(
+    VkDevice device,
+        VkDescriptorSetLayout descriptorSetLayout,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreateDescriptorPool(
+    VkDevice device,
+        const VkDescriptorPoolCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDescriptorPool* pDescriptorPool);
+    void vkDestroyDescriptorPool(
+    VkDevice device,
+        VkDescriptorPool descriptorPool,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkResetDescriptorPool(
+    VkDevice device,
+        VkDescriptorPool descriptorPool,
+        VkDescriptorPoolResetFlags flags);
+    VkResult vkAllocateDescriptorSets(
+    VkDevice device,
+        const VkDescriptorSetAllocateInfo* pAllocateInfo,
+        VkDescriptorSet* pDescriptorSets);
+    VkResult vkFreeDescriptorSets(
+    VkDevice device,
+        VkDescriptorPool descriptorPool,
+        uint32_t descriptorSetCount,
+        const VkDescriptorSet* pDescriptorSets);
+    void vkUpdateDescriptorSets(
+    VkDevice device,
+        uint32_t descriptorWriteCount,
+        const VkWriteDescriptorSet* pDescriptorWrites,
+        uint32_t descriptorCopyCount,
+        const VkCopyDescriptorSet* pDescriptorCopies);
+    VkResult vkCreateFramebuffer(
+    VkDevice device,
+        const VkFramebufferCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkFramebuffer* pFramebuffer);
+    void vkDestroyFramebuffer(
+    VkDevice device,
+        VkFramebuffer framebuffer,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreateRenderPass(
+    VkDevice device,
+        const VkRenderPassCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkRenderPass* pRenderPass);
+    void vkDestroyRenderPass(
+    VkDevice device,
+        VkRenderPass renderPass,
+        const VkAllocationCallbacks* pAllocator);
+    void vkGetRenderAreaGranularity(
+    VkDevice device,
+        VkRenderPass renderPass,
+        VkExtent2D* pGranularity);
+    VkResult vkCreateCommandPool(
+    VkDevice device,
+        const VkCommandPoolCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkCommandPool* pCommandPool);
+    void vkDestroyCommandPool(
+    VkDevice device,
+        VkCommandPool commandPool,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkResetCommandPool(
+    VkDevice device,
+        VkCommandPool commandPool,
+        VkCommandPoolResetFlags flags);
+    VkResult vkAllocateCommandBuffers(
+    VkDevice device,
+        const VkCommandBufferAllocateInfo* pAllocateInfo,
+        VkCommandBuffer* pCommandBuffers);
+    void vkFreeCommandBuffers(
+    VkDevice device,
+        VkCommandPool commandPool,
+        uint32_t commandBufferCount,
+        const VkCommandBuffer* pCommandBuffers);
+    VkResult vkBeginCommandBuffer(
+    VkCommandBuffer commandBuffer,
+        const VkCommandBufferBeginInfo* pBeginInfo);
+    VkResult vkEndCommandBuffer(
+    VkCommandBuffer commandBuffer);
+    VkResult vkResetCommandBuffer(
+    VkCommandBuffer commandBuffer,
+        VkCommandBufferResetFlags flags);
+    void vkCmdBindPipeline(
+    VkCommandBuffer commandBuffer,
+        VkPipelineBindPoint pipelineBindPoint,
+        VkPipeline pipeline);
+    void vkCmdSetViewport(
+    VkCommandBuffer commandBuffer,
+        uint32_t firstViewport,
+        uint32_t viewportCount,
+        const VkViewport* pViewports);
+    void vkCmdSetScissor(
+    VkCommandBuffer commandBuffer,
+        uint32_t firstScissor,
+        uint32_t scissorCount,
+        const VkRect2D* pScissors);
+    void vkCmdSetLineWidth(
+    VkCommandBuffer commandBuffer,
+        float lineWidth);
+    void vkCmdSetDepthBias(
+    VkCommandBuffer commandBuffer,
+        float depthBiasConstantFactor,
+        float depthBiasClamp,
+        float depthBiasSlopeFactor);
+    void vkCmdSetBlendConstants(
+    VkCommandBuffer commandBuffer,
+        const float blendConstants);
+    void vkCmdSetDepthBounds(
+    VkCommandBuffer commandBuffer,
+        float minDepthBounds,
+        float maxDepthBounds);
+    void vkCmdSetStencilCompareMask(
+    VkCommandBuffer commandBuffer,
+        VkStencilFaceFlags faceMask,
+        uint32_t compareMask);
+    void vkCmdSetStencilWriteMask(
+    VkCommandBuffer commandBuffer,
+        VkStencilFaceFlags faceMask,
+        uint32_t writeMask);
+    void vkCmdSetStencilReference(
+    VkCommandBuffer commandBuffer,
+        VkStencilFaceFlags faceMask,
+        uint32_t reference);
+    void vkCmdBindDescriptorSets(
+    VkCommandBuffer commandBuffer,
+        VkPipelineBindPoint pipelineBindPoint,
+        VkPipelineLayout layout,
+        uint32_t firstSet,
+        uint32_t descriptorSetCount,
+        const VkDescriptorSet* pDescriptorSets,
+        uint32_t dynamicOffsetCount,
+        const uint32_t* pDynamicOffsets);
+    void vkCmdBindIndexBuffer(
+    VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        VkIndexType indexType);
+    void vkCmdBindVertexBuffers(
+    VkCommandBuffer commandBuffer,
+        uint32_t firstBinding,
+        uint32_t bindingCount,
+        const VkBuffer* pBuffers,
+        const VkDeviceSize* pOffsets);
+    void vkCmdDraw(
+    VkCommandBuffer commandBuffer,
+        uint32_t vertexCount,
+        uint32_t instanceCount,
+        uint32_t firstVertex,
+        uint32_t firstInstance);
+    void vkCmdDrawIndexed(
+    VkCommandBuffer commandBuffer,
+        uint32_t indexCount,
+        uint32_t instanceCount,
+        uint32_t firstIndex,
+        int32_t vertexOffset,
+        uint32_t firstInstance);
+    void vkCmdDrawIndirect(
+    VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        uint32_t drawCount,
+        uint32_t stride);
+    void vkCmdDrawIndexedIndirect(
+    VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        uint32_t drawCount,
+        uint32_t stride);
+    void vkCmdDispatch(
+    VkCommandBuffer commandBuffer,
+        uint32_t groupCountX,
+        uint32_t groupCountY,
+        uint32_t groupCountZ);
+    void vkCmdDispatchIndirect(
+    VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset);
+    void vkCmdCopyBuffer(
+    VkCommandBuffer commandBuffer,
+        VkBuffer srcBuffer,
+        VkBuffer dstBuffer,
+        uint32_t regionCount,
+        const VkBufferCopy* pRegions);
+    void vkCmdCopyImage(
+    VkCommandBuffer commandBuffer,
+        VkImage srcImage,
+        VkImageLayout srcImageLayout,
+        VkImage dstImage,
+        VkImageLayout dstImageLayout,
+        uint32_t regionCount,
+        const VkImageCopy* pRegions);
+    void vkCmdBlitImage(
+    VkCommandBuffer commandBuffer,
+        VkImage srcImage,
+        VkImageLayout srcImageLayout,
+        VkImage dstImage,
+        VkImageLayout dstImageLayout,
+        uint32_t regionCount,
+        const VkImageBlit* pRegions,
+        VkFilter filter);
+    void vkCmdCopyBufferToImage(
+    VkCommandBuffer commandBuffer,
+        VkBuffer srcBuffer,
+        VkImage dstImage,
+        VkImageLayout dstImageLayout,
+        uint32_t regionCount,
+        const VkBufferImageCopy* pRegions);
+    void vkCmdCopyImageToBuffer(
+    VkCommandBuffer commandBuffer,
+        VkImage srcImage,
+        VkImageLayout srcImageLayout,
+        VkBuffer dstBuffer,
+        uint32_t regionCount,
+        const VkBufferImageCopy* pRegions);
+    void vkCmdUpdateBuffer(
+    VkCommandBuffer commandBuffer,
+        VkBuffer dstBuffer,
+        VkDeviceSize dstOffset,
+        VkDeviceSize dataSize,
+        const void* pData);
+    void vkCmdFillBuffer(
+    VkCommandBuffer commandBuffer,
+        VkBuffer dstBuffer,
+        VkDeviceSize dstOffset,
+        VkDeviceSize size,
+        uint32_t data);
+    void vkCmdClearColorImage(
+    VkCommandBuffer commandBuffer,
+        VkImage image,
+        VkImageLayout imageLayout,
+        const VkClearColorValue* pColor,
+        uint32_t rangeCount,
+        const VkImageSubresourceRange* pRanges);
+    void vkCmdClearDepthStencilImage(
+    VkCommandBuffer commandBuffer,
+        VkImage image,
+        VkImageLayout imageLayout,
+        const VkClearDepthStencilValue* pDepthStencil,
+        uint32_t rangeCount,
+        const VkImageSubresourceRange* pRanges);
+    void vkCmdClearAttachments(
+    VkCommandBuffer commandBuffer,
+        uint32_t attachmentCount,
+        const VkClearAttachment* pAttachments,
+        uint32_t rectCount,
+        const VkClearRect* pRects);
+    void vkCmdResolveImage(
+    VkCommandBuffer commandBuffer,
+        VkImage srcImage,
+        VkImageLayout srcImageLayout,
+        VkImage dstImage,
+        VkImageLayout dstImageLayout,
+        uint32_t regionCount,
+        const VkImageResolve* pRegions);
+    void vkCmdSetEvent(
+    VkCommandBuffer commandBuffer,
+        VkEvent event,
+        VkPipelineStageFlags stageMask);
+    void vkCmdResetEvent(
+    VkCommandBuffer commandBuffer,
+        VkEvent event,
+        VkPipelineStageFlags stageMask);
+    void vkCmdWaitEvents(
+    VkCommandBuffer commandBuffer,
+        uint32_t eventCount,
+        const VkEvent* pEvents,
+        VkPipelineStageFlags srcStageMask,
+        VkPipelineStageFlags dstStageMask,
+        uint32_t memoryBarrierCount,
+        const VkMemoryBarrier* pMemoryBarriers,
+        uint32_t bufferMemoryBarrierCount,
+        const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+        uint32_t imageMemoryBarrierCount,
+        const VkImageMemoryBarrier* pImageMemoryBarriers);
+    void vkCmdPipelineBarrier(
+    VkCommandBuffer commandBuffer,
+        VkPipelineStageFlags srcStageMask,
+        VkPipelineStageFlags dstStageMask,
+        VkDependencyFlags dependencyFlags,
+        uint32_t memoryBarrierCount,
+        const VkMemoryBarrier* pMemoryBarriers,
+        uint32_t bufferMemoryBarrierCount,
+        const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+        uint32_t imageMemoryBarrierCount,
+        const VkImageMemoryBarrier* pImageMemoryBarriers);
+    void vkCmdBeginQuery(
+    VkCommandBuffer commandBuffer,
+        VkQueryPool queryPool,
+        uint32_t query,
+        VkQueryControlFlags flags);
+    void vkCmdEndQuery(
+    VkCommandBuffer commandBuffer,
+        VkQueryPool queryPool,
+        uint32_t query);
+    void vkCmdResetQueryPool(
+    VkCommandBuffer commandBuffer,
+        VkQueryPool queryPool,
+        uint32_t firstQuery,
+        uint32_t queryCount);
+    void vkCmdWriteTimestamp(
+    VkCommandBuffer commandBuffer,
+        VkPipelineStageFlagBits pipelineStage,
+        VkQueryPool queryPool,
+        uint32_t query);
+    void vkCmdCopyQueryPoolResults(
+    VkCommandBuffer commandBuffer,
+        VkQueryPool queryPool,
+        uint32_t firstQuery,
+        uint32_t queryCount,
+        VkBuffer dstBuffer,
+        VkDeviceSize dstOffset,
+        VkDeviceSize stride,
+        VkQueryResultFlags flags);
+    void vkCmdPushConstants(
+    VkCommandBuffer commandBuffer,
+        VkPipelineLayout layout,
+        VkShaderStageFlags stageFlags,
+        uint32_t offset,
+        uint32_t size,
+        const void* pValues);
+    void vkCmdBeginRenderPass(
+    VkCommandBuffer commandBuffer,
+        const VkRenderPassBeginInfo* pRenderPassBegin,
+        VkSubpassContents contents);
+    void vkCmdNextSubpass(
+    VkCommandBuffer commandBuffer,
+        VkSubpassContents contents);
+    void vkCmdEndRenderPass(
+    VkCommandBuffer commandBuffer);
+    void vkCmdExecuteCommands(
+    VkCommandBuffer commandBuffer,
+        uint32_t commandBufferCount,
+        const VkCommandBuffer* pCommandBuffers);
+#endif
+#ifdef VK_VERSION_1_1
+    VkResult vkEnumerateInstanceVersion(
+    uint32_t* pApiVersion);
+    VkResult vkBindBufferMemory2(
+    VkDevice device,
+        uint32_t bindInfoCount,
+        const VkBindBufferMemoryInfo* pBindInfos);
+    VkResult vkBindImageMemory2(
+    VkDevice device,
+        uint32_t bindInfoCount,
+        const VkBindImageMemoryInfo* pBindInfos);
+    void vkGetDeviceGroupPeerMemoryFeatures(
+    VkDevice device,
+        uint32_t heapIndex,
+        uint32_t localDeviceIndex,
+        uint32_t remoteDeviceIndex,
+        VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+    void vkCmdSetDeviceMask(
+    VkCommandBuffer commandBuffer,
+        uint32_t deviceMask);
+    void vkCmdDispatchBase(
+    VkCommandBuffer commandBuffer,
+        uint32_t baseGroupX,
+        uint32_t baseGroupY,
+        uint32_t baseGroupZ,
+        uint32_t groupCountX,
+        uint32_t groupCountY,
+        uint32_t groupCountZ);
+    VkResult vkEnumeratePhysicalDeviceGroups(
+    VkInstance instance,
+        uint32_t* pPhysicalDeviceGroupCount,
+        VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+    void vkGetImageMemoryRequirements2(
+    VkDevice device,
+        const VkImageMemoryRequirementsInfo2* pInfo,
+        VkMemoryRequirements2* pMemoryRequirements);
+    void vkGetBufferMemoryRequirements2(
+    VkDevice device,
+        const VkBufferMemoryRequirementsInfo2* pInfo,
+        VkMemoryRequirements2* pMemoryRequirements);
+    void vkGetImageSparseMemoryRequirements2(
+    VkDevice device,
+        const VkImageSparseMemoryRequirementsInfo2* pInfo,
+        uint32_t* pSparseMemoryRequirementCount,
+        VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+    void vkGetPhysicalDeviceFeatures2(
+    VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceFeatures2* pFeatures);
+    void vkGetPhysicalDeviceProperties2(
+    VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceProperties2* pProperties);
+    void vkGetPhysicalDeviceFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkFormatProperties2* pFormatProperties);
+    VkResult vkGetPhysicalDeviceImageFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+        VkImageFormatProperties2* pImageFormatProperties);
+    void vkGetPhysicalDeviceQueueFamilyProperties2(
+    VkPhysicalDevice physicalDevice,
+        uint32_t* pQueueFamilyPropertyCount,
+        VkQueueFamilyProperties2* pQueueFamilyProperties);
+    void vkGetPhysicalDeviceMemoryProperties2(
+    VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+    void vkGetPhysicalDeviceSparseImageFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+        uint32_t* pPropertyCount,
+        VkSparseImageFormatProperties2* pProperties);
+    void vkTrimCommandPool(
+    VkDevice device,
+        VkCommandPool commandPool,
+        VkCommandPoolTrimFlags flags);
+    void vkGetDeviceQueue2(
+    VkDevice device,
+        const VkDeviceQueueInfo2* pQueueInfo,
+        VkQueue* pQueue);
+    VkResult vkCreateSamplerYcbcrConversion(
+    VkDevice device,
+        const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSamplerYcbcrConversion* pYcbcrConversion);
+    void vkDestroySamplerYcbcrConversion(
+    VkDevice device,
+        VkSamplerYcbcrConversion ycbcrConversion,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreateDescriptorUpdateTemplate(
+    VkDevice device,
+        const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+    void vkDestroyDescriptorUpdateTemplate(
+    VkDevice device,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+        const VkAllocationCallbacks* pAllocator);
+    void vkUpdateDescriptorSetWithTemplate(
+    VkDevice device,
+        VkDescriptorSet descriptorSet,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+        const void* pData);
+    void vkGetPhysicalDeviceExternalBufferProperties(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+        VkExternalBufferProperties* pExternalBufferProperties);
+    void vkGetPhysicalDeviceExternalFenceProperties(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+        VkExternalFenceProperties* pExternalFenceProperties);
+    void vkGetPhysicalDeviceExternalSemaphoreProperties(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+        VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+    void vkGetDescriptorSetLayoutSupport(
+    VkDevice device,
+        const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+        VkDescriptorSetLayoutSupport* pSupport);
+#endif
+#ifdef VK_KHR_surface
+    void vkDestroySurfaceKHR(
+    VkInstance instance,
+        VkSurfaceKHR surface,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex,
+        VkSurfaceKHR surface,
+        VkBool32* pSupported);
+    VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+    VkPhysicalDevice physicalDevice,
+        VkSurfaceKHR surface,
+        VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+    VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
+    VkPhysicalDevice physicalDevice,
+        VkSurfaceKHR surface,
+        uint32_t* pSurfaceFormatCount,
+        VkSurfaceFormatKHR* pSurfaceFormats);
+    VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
+    VkPhysicalDevice physicalDevice,
+        VkSurfaceKHR surface,
+        uint32_t* pPresentModeCount,
+        VkPresentModeKHR* pPresentModes);
+#endif
+#ifdef VK_KHR_swapchain
+    VkResult vkCreateSwapchainKHR(
+    VkDevice device,
+        const VkSwapchainCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSwapchainKHR* pSwapchain);
+    void vkDestroySwapchainKHR(
+    VkDevice device,
+        VkSwapchainKHR swapchain,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkGetSwapchainImagesKHR(
+    VkDevice device,
+        VkSwapchainKHR swapchain,
+        uint32_t* pSwapchainImageCount,
+        VkImage* pSwapchainImages);
+    VkResult vkAcquireNextImageKHR(
+    VkDevice device,
+        VkSwapchainKHR swapchain,
+        uint64_t timeout,
+        VkSemaphore semaphore,
+        VkFence fence,
+        uint32_t* pImageIndex);
+    VkResult vkQueuePresentKHR(
+    VkQueue queue,
+        const VkPresentInfoKHR* pPresentInfo);
+    VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
+    VkDevice device,
+        VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
+    VkResult vkGetDeviceGroupSurfacePresentModesKHR(
+    VkDevice device,
+        VkSurfaceKHR surface,
+        VkDeviceGroupPresentModeFlagsKHR* pModes);
+    VkResult vkGetPhysicalDevicePresentRectanglesKHR(
+    VkPhysicalDevice physicalDevice,
+        VkSurfaceKHR surface,
+        uint32_t* pRectCount,
+        VkRect2D* pRects);
+    VkResult vkAcquireNextImage2KHR(
+    VkDevice device,
+        const VkAcquireNextImageInfoKHR* pAcquireInfo,
+        uint32_t* pImageIndex);
+#endif
+#ifdef VK_KHR_display
+    VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t* pPropertyCount,
+        VkDisplayPropertiesKHR* pProperties);
+    VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t* pPropertyCount,
+        VkDisplayPlanePropertiesKHR* pProperties);
+    VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t planeIndex,
+        uint32_t* pDisplayCount,
+        VkDisplayKHR* pDisplays);
+    VkResult vkGetDisplayModePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+        VkDisplayKHR display,
+        uint32_t* pPropertyCount,
+        VkDisplayModePropertiesKHR* pProperties);
+    VkResult vkCreateDisplayModeKHR(
+    VkPhysicalDevice physicalDevice,
+        VkDisplayKHR display,
+        const VkDisplayModeCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDisplayModeKHR* pMode);
+    VkResult vkGetDisplayPlaneCapabilitiesKHR(
+    VkPhysicalDevice physicalDevice,
+        VkDisplayModeKHR mode,
+        uint32_t planeIndex,
+        VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+    VkResult vkCreateDisplayPlaneSurfaceKHR(
+    VkInstance instance,
+        const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_KHR_display_swapchain
+    VkResult vkCreateSharedSwapchainsKHR(
+    VkDevice device,
+        uint32_t swapchainCount,
+        const VkSwapchainCreateInfoKHR* pCreateInfos,
+        const VkAllocationCallbacks* pAllocator,
+        VkSwapchainKHR* pSwapchains);
+#endif
+#ifdef VK_KHR_xlib_surface
+    VkResult vkCreateXlibSurfaceKHR(
+    VkInstance instance,
+        const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+    VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex,
+        Display* dpy,
+        VisualID visualID);
+#endif
+#ifdef VK_KHR_xcb_surface
+    VkResult vkCreateXcbSurfaceKHR(
+    VkInstance instance,
+        const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+    VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex,
+        xcb_connection_t* connection,
+        xcb_visualid_t visual_id);
+#endif
+#ifdef VK_KHR_wayland_surface
+    VkResult vkCreateWaylandSurfaceKHR(
+    VkInstance instance,
+        const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+    VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex,
+        wl_display* display);
+#endif
+#ifdef VK_KHR_mir_surface
+    VkResult vkCreateMirSurfaceKHR(
+    VkInstance instance,
+        const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+    VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex,
+        MirConnection* connection);
+#endif
+#ifdef VK_KHR_android_surface
+    VkResult vkCreateAndroidSurfaceKHR(
+    VkInstance instance,
+        const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_KHR_win32_surface
+    VkResult vkCreateWin32SurfaceKHR(
+    VkInstance instance,
+        const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+    VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex);
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+    void vkGetPhysicalDeviceFeatures2KHR(
+    VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceFeatures2* pFeatures);
+    void vkGetPhysicalDeviceProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceProperties2* pProperties);
+    void vkGetPhysicalDeviceFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkFormatProperties2* pFormatProperties);
+    VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+        VkImageFormatProperties2* pImageFormatProperties);
+    void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t* pQueueFamilyPropertyCount,
+        VkQueueFamilyProperties2* pQueueFamilyProperties);
+    void vkGetPhysicalDeviceMemoryProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+    void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+        uint32_t* pPropertyCount,
+        VkSparseImageFormatProperties2* pProperties);
+#endif
+#ifdef VK_KHR_device_group
+    void vkGetDeviceGroupPeerMemoryFeaturesKHR(
+    VkDevice device,
+        uint32_t heapIndex,
+        uint32_t localDeviceIndex,
+        uint32_t remoteDeviceIndex,
+        VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+    void vkCmdSetDeviceMaskKHR(
+    VkCommandBuffer commandBuffer,
+        uint32_t deviceMask);
+    void vkCmdDispatchBaseKHR(
+    VkCommandBuffer commandBuffer,
+        uint32_t baseGroupX,
+        uint32_t baseGroupY,
+        uint32_t baseGroupZ,
+        uint32_t groupCountX,
+        uint32_t groupCountY,
+        uint32_t groupCountZ);
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+    void vkTrimCommandPoolKHR(
+    VkDevice device,
+        VkCommandPool commandPool,
+        VkCommandPoolTrimFlags flags);
+#endif
+#ifdef VK_KHR_device_group_creation
+    VkResult vkEnumeratePhysicalDeviceGroupsKHR(
+    VkInstance instance,
+        uint32_t* pPhysicalDeviceGroupCount,
+        VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+    void vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+        VkExternalBufferProperties* pExternalBufferProperties);
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+    VkResult vkGetMemoryWin32HandleKHR(
+    VkDevice device,
+        const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+        HANDLE* pHandle);
+    VkResult vkGetMemoryWin32HandlePropertiesKHR(
+    VkDevice device,
+        VkExternalMemoryHandleTypeFlagBits handleType,
+        HANDLE handle,
+        VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+#endif
+#ifdef VK_KHR_external_memory_fd
+    VkResult vkGetMemoryFdKHR(
+    VkDevice device,
+        const VkMemoryGetFdInfoKHR* pGetFdInfo,
+        int* pFd);
+    VkResult vkGetMemoryFdPropertiesKHR(
+    VkDevice device,
+        VkExternalMemoryHandleTypeFlagBits handleType,
+        int fd,
+        VkMemoryFdPropertiesKHR* pMemoryFdProperties);
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+    void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+        VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+    VkResult vkImportSemaphoreWin32HandleKHR(
+    VkDevice device,
+        const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+    VkResult vkGetSemaphoreWin32HandleKHR(
+    VkDevice device,
+        const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+        HANDLE* pHandle);
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+    VkResult vkImportSemaphoreFdKHR(
+    VkDevice device,
+        const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
+    VkResult vkGetSemaphoreFdKHR(
+    VkDevice device,
+        const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+        int* pFd);
+#endif
+#ifdef VK_KHR_push_descriptor
+    void vkCmdPushDescriptorSetKHR(
+    VkCommandBuffer commandBuffer,
+        VkPipelineBindPoint pipelineBindPoint,
+        VkPipelineLayout layout,
+        uint32_t set,
+        uint32_t descriptorWriteCount,
+        const VkWriteDescriptorSet* pDescriptorWrites);
+    void vkCmdPushDescriptorSetWithTemplateKHR(
+    VkCommandBuffer commandBuffer,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+        VkPipelineLayout layout,
+        uint32_t set,
+        const void* pData);
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+    VkResult vkCreateDescriptorUpdateTemplateKHR(
+    VkDevice device,
+        const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+    void vkDestroyDescriptorUpdateTemplateKHR(
+    VkDevice device,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+        const VkAllocationCallbacks* pAllocator);
+    void vkUpdateDescriptorSetWithTemplateKHR(
+    VkDevice device,
+        VkDescriptorSet descriptorSet,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+        const void* pData);
+#endif
+#ifdef VK_KHR_create_renderpass2
+    VkResult vkCreateRenderPass2KHR(
+    VkDevice device,
+        const VkRenderPassCreateInfo2KHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkRenderPass* pRenderPass);
+    void vkCmdBeginRenderPass2KHR(
+    VkCommandBuffer commandBuffer,
+        const VkRenderPassBeginInfo* pRenderPassBegin,
+        const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
+    void vkCmdNextSubpass2KHR(
+    VkCommandBuffer commandBuffer,
+        const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+        const VkSubpassEndInfoKHR* pSubpassEndInfo);
+    void vkCmdEndRenderPass2KHR(
+    VkCommandBuffer commandBuffer,
+        const VkSubpassEndInfoKHR* pSubpassEndInfo);
+#endif
+#ifdef VK_KHR_shared_presentable_image
+    VkResult vkGetSwapchainStatusKHR(
+    VkDevice device,
+        VkSwapchainKHR swapchain);
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+    void vkGetPhysicalDeviceExternalFencePropertiesKHR(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+        VkExternalFenceProperties* pExternalFenceProperties);
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+    VkResult vkImportFenceWin32HandleKHR(
+    VkDevice device,
+        const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+    VkResult vkGetFenceWin32HandleKHR(
+    VkDevice device,
+        const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+        HANDLE* pHandle);
+#endif
+#ifdef VK_KHR_external_fence_fd
+    VkResult vkImportFenceFdKHR(
+    VkDevice device,
+        const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
+    VkResult vkGetFenceFdKHR(
+    VkDevice device,
+        const VkFenceGetFdInfoKHR* pGetFdInfo,
+        int* pFd);
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+        VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+    VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
+    VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+        uint32_t* pSurfaceFormatCount,
+        VkSurfaceFormat2KHR* pSurfaceFormats);
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+    VkResult vkGetPhysicalDeviceDisplayProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t* pPropertyCount,
+        VkDisplayProperties2KHR* pProperties);
+    VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+        uint32_t* pPropertyCount,
+        VkDisplayPlaneProperties2KHR* pProperties);
+    VkResult vkGetDisplayModeProperties2KHR(
+    VkPhysicalDevice physicalDevice,
+        VkDisplayKHR display,
+        uint32_t* pPropertyCount,
+        VkDisplayModeProperties2KHR* pProperties);
+    VkResult vkGetDisplayPlaneCapabilities2KHR(
+    VkPhysicalDevice physicalDevice,
+        const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+        VkDisplayPlaneCapabilities2KHR* pCapabilities);
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+    void vkGetImageMemoryRequirements2KHR(
+    VkDevice device,
+        const VkImageMemoryRequirementsInfo2* pInfo,
+        VkMemoryRequirements2* pMemoryRequirements);
+    void vkGetBufferMemoryRequirements2KHR(
+    VkDevice device,
+        const VkBufferMemoryRequirementsInfo2* pInfo,
+        VkMemoryRequirements2* pMemoryRequirements);
+    void vkGetImageSparseMemoryRequirements2KHR(
+    VkDevice device,
+        const VkImageSparseMemoryRequirementsInfo2* pInfo,
+        uint32_t* pSparseMemoryRequirementCount,
+        VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+    VkResult vkCreateSamplerYcbcrConversionKHR(
+    VkDevice device,
+        const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSamplerYcbcrConversion* pYcbcrConversion);
+    void vkDestroySamplerYcbcrConversionKHR(
+    VkDevice device,
+        VkSamplerYcbcrConversion ycbcrConversion,
+        const VkAllocationCallbacks* pAllocator);
+#endif
+#ifdef VK_KHR_bind_memory2
+    VkResult vkBindBufferMemory2KHR(
+    VkDevice device,
+        uint32_t bindInfoCount,
+        const VkBindBufferMemoryInfo* pBindInfos);
+    VkResult vkBindImageMemory2KHR(
+    VkDevice device,
+        uint32_t bindInfoCount,
+        const VkBindImageMemoryInfo* pBindInfos);
+#endif
+#ifdef VK_KHR_maintenance3
+    void vkGetDescriptorSetLayoutSupportKHR(
+    VkDevice device,
+        const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+        VkDescriptorSetLayoutSupport* pSupport);
+#endif
+#ifdef VK_KHR_draw_indirect_count
+    void vkCmdDrawIndirectCountKHR(
+    VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        VkBuffer countBuffer,
+        VkDeviceSize countBufferOffset,
+        uint32_t maxDrawCount,
+        uint32_t stride);
+    void vkCmdDrawIndexedIndirectCountKHR(
+    VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        VkBuffer countBuffer,
+        VkDeviceSize countBufferOffset,
+        uint32_t maxDrawCount,
+        uint32_t stride);
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+    VkResult vkGetSwapchainGrallocUsageANDROID(
+    VkDevice device,
+        VkFormat format,
+        VkImageUsageFlags imageUsage,
+        int* grallocUsage);
+    VkResult vkAcquireImageANDROID(
+    VkDevice device,
+        VkImage image,
+        int nativeFenceFd,
+        VkSemaphore semaphore,
+        VkFence fence);
+    VkResult vkQueueSignalReleaseImageANDROID(
+    VkQueue queue,
+        uint32_t waitSemaphoreCount,
+        const VkSemaphore* pWaitSemaphores,
+        VkImage image,
+        int* pNativeFenceFd);
+#endif
+#ifdef VK_EXT_debug_report
+    VkResult vkCreateDebugReportCallbackEXT(
+    VkInstance instance,
+        const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDebugReportCallbackEXT* pCallback);
+    void vkDestroyDebugReportCallbackEXT(
+    VkInstance instance,
+        VkDebugReportCallbackEXT callback,
+        const VkAllocationCallbacks* pAllocator);
+    void vkDebugReportMessageEXT(
+    VkInstance instance,
+        VkDebugReportFlagsEXT flags,
+        VkDebugReportObjectTypeEXT objectType,
+        uint64_t object,
+        size_t location,
+        int32_t messageCode,
+        const char* pLayerPrefix,
+        const char* pMessage);
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+    VkResult vkDebugMarkerSetObjectTagEXT(
+    VkDevice device,
+        const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+    VkResult vkDebugMarkerSetObjectNameEXT(
+    VkDevice device,
+        const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+    void vkCmdDebugMarkerBeginEXT(
+    VkCommandBuffer commandBuffer,
+        const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+    void vkCmdDebugMarkerEndEXT(
+    VkCommandBuffer commandBuffer);
+    void vkCmdDebugMarkerInsertEXT(
+    VkCommandBuffer commandBuffer,
+        const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+    void vkCmdDrawIndirectCountAMD(
+    VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        VkBuffer countBuffer,
+        VkDeviceSize countBufferOffset,
+        uint32_t maxDrawCount,
+        uint32_t stride);
+    void vkCmdDrawIndexedIndirectCountAMD(
+    VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        VkBuffer countBuffer,
+        VkDeviceSize countBufferOffset,
+        uint32_t maxDrawCount,
+        uint32_t stride);
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+    VkResult vkGetShaderInfoAMD(
+    VkDevice device,
+        VkPipeline pipeline,
+        VkShaderStageFlagBits shaderStage,
+        VkShaderInfoTypeAMD infoType,
+        size_t* pInfoSize,
+        void* pInfo);
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+    VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkImageType type,
+        VkImageTiling tiling,
+        VkImageUsageFlags usage,
+        VkImageCreateFlags flags,
+        VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+        VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+    VkResult vkGetMemoryWin32HandleNV(
+    VkDevice device,
+        VkDeviceMemory memory,
+        VkExternalMemoryHandleTypeFlagsNV handleType,
+        HANDLE* pHandle);
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+    VkResult vkCreateViSurfaceNN(
+    VkInstance instance,
+        const VkViSurfaceCreateInfoNN* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+    void vkCmdBeginConditionalRenderingEXT(
+    VkCommandBuffer commandBuffer,
+        const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+    void vkCmdEndConditionalRenderingEXT(
+    VkCommandBuffer commandBuffer);
+#endif
+#ifdef VK_NVX_device_generated_commands
+    void vkCmdProcessCommandsNVX(
+    VkCommandBuffer commandBuffer,
+        const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
+    void vkCmdReserveSpaceForCommandsNVX(
+    VkCommandBuffer commandBuffer,
+        const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
+    VkResult vkCreateIndirectCommandsLayoutNVX(
+    VkDevice device,
+        const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
+    void vkDestroyIndirectCommandsLayoutNVX(
+    VkDevice device,
+        VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkCreateObjectTableNVX(
+    VkDevice device,
+        const VkObjectTableCreateInfoNVX* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkObjectTableNVX* pObjectTable);
+    void vkDestroyObjectTableNVX(
+    VkDevice device,
+        VkObjectTableNVX objectTable,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkRegisterObjectsNVX(
+    VkDevice device,
+        VkObjectTableNVX objectTable,
+        uint32_t objectCount,
+        const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+        const uint32_t* pObjectIndices);
+    VkResult vkUnregisterObjectsNVX(
+    VkDevice device,
+        VkObjectTableNVX objectTable,
+        uint32_t objectCount,
+        const VkObjectEntryTypeNVX* pObjectEntryTypes,
+        const uint32_t* pObjectIndices);
+    void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    VkPhysicalDevice physicalDevice,
+        VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+        VkDeviceGeneratedCommandsLimitsNVX* pLimits);
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+    void vkCmdSetViewportWScalingNV(
+    VkCommandBuffer commandBuffer,
+        uint32_t firstViewport,
+        uint32_t viewportCount,
+        const VkViewportWScalingNV* pViewportWScalings);
+#endif
+#ifdef VK_EXT_direct_mode_display
+    VkResult vkReleaseDisplayEXT(
+    VkPhysicalDevice physicalDevice,
+        VkDisplayKHR display);
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+    VkResult vkAcquireXlibDisplayEXT(
+    VkPhysicalDevice physicalDevice,
+        Display* dpy,
+        VkDisplayKHR display);
+    VkResult vkGetRandROutputDisplayEXT(
+    VkPhysicalDevice physicalDevice,
+        Display* dpy,
+        RROutput rrOutput,
+        VkDisplayKHR* pDisplay);
+#endif
+#ifdef VK_EXT_display_surface_counter
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+    VkPhysicalDevice physicalDevice,
+        VkSurfaceKHR surface,
+        VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
+#endif
+#ifdef VK_EXT_display_control
+    VkResult vkDisplayPowerControlEXT(
+    VkDevice device,
+        VkDisplayKHR display,
+        const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
+    VkResult vkRegisterDeviceEventEXT(
+    VkDevice device,
+        const VkDeviceEventInfoEXT* pDeviceEventInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkFence* pFence);
+    VkResult vkRegisterDisplayEventEXT(
+    VkDevice device,
+        VkDisplayKHR display,
+        const VkDisplayEventInfoEXT* pDisplayEventInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkFence* pFence);
+    VkResult vkGetSwapchainCounterEXT(
+    VkDevice device,
+        VkSwapchainKHR swapchain,
+        VkSurfaceCounterFlagBitsEXT counter,
+        uint64_t* pCounterValue);
+#endif
+#ifdef VK_GOOGLE_display_timing
+    VkResult vkGetRefreshCycleDurationGOOGLE(
+    VkDevice device,
+        VkSwapchainKHR swapchain,
+        VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
+    VkResult vkGetPastPresentationTimingGOOGLE(
+    VkDevice device,
+        VkSwapchainKHR swapchain,
+        uint32_t* pPresentationTimingCount,
+        VkPastPresentationTimingGOOGLE* pPresentationTimings);
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+    void vkCmdSetDiscardRectangleEXT(
+    VkCommandBuffer commandBuffer,
+        uint32_t firstDiscardRectangle,
+        uint32_t discardRectangleCount,
+        const VkRect2D* pDiscardRectangles);
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+    void vkSetHdrMetadataEXT(
+    VkDevice device,
+        uint32_t swapchainCount,
+        const VkSwapchainKHR* pSwapchains,
+        const VkHdrMetadataEXT* pMetadata);
+#endif
+#ifdef VK_MVK_ios_surface
+    VkResult vkCreateIOSSurfaceMVK(
+    VkInstance instance,
+        const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_MVK_macos_surface
+    VkResult vkCreateMacOSSurfaceMVK(
+    VkInstance instance,
+        const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+    VkResult vkSetDebugUtilsObjectNameEXT(
+    VkDevice device,
+        const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
+    VkResult vkSetDebugUtilsObjectTagEXT(
+    VkDevice device,
+        const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
+    void vkQueueBeginDebugUtilsLabelEXT(
+    VkQueue queue,
+        const VkDebugUtilsLabelEXT* pLabelInfo);
+    void vkQueueEndDebugUtilsLabelEXT(
+    VkQueue queue);
+    void vkQueueInsertDebugUtilsLabelEXT(
+    VkQueue queue,
+        const VkDebugUtilsLabelEXT* pLabelInfo);
+    void vkCmdBeginDebugUtilsLabelEXT(
+    VkCommandBuffer commandBuffer,
+        const VkDebugUtilsLabelEXT* pLabelInfo);
+    void vkCmdEndDebugUtilsLabelEXT(
+    VkCommandBuffer commandBuffer);
+    void vkCmdInsertDebugUtilsLabelEXT(
+    VkCommandBuffer commandBuffer,
+        const VkDebugUtilsLabelEXT* pLabelInfo);
+    VkResult vkCreateDebugUtilsMessengerEXT(
+    VkInstance instance,
+        const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDebugUtilsMessengerEXT* pMessenger);
+    void vkDestroyDebugUtilsMessengerEXT(
+    VkInstance instance,
+        VkDebugUtilsMessengerEXT messenger,
+        const VkAllocationCallbacks* pAllocator);
+    void vkSubmitDebugUtilsMessageEXT(
+    VkInstance instance,
+        VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+        VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+        const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+    VkResult vkGetAndroidHardwareBufferPropertiesANDROID(
+    VkDevice device,
+        const AHardwareBuffer* buffer,
+        VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+    VkResult vkGetMemoryAndroidHardwareBufferANDROID(
+    VkDevice device,
+        const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+        AHardwareBuffer** pBuffer);
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+    void vkCmdSetSampleLocationsEXT(
+    VkCommandBuffer commandBuffer,
+        const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
+    void vkGetPhysicalDeviceMultisamplePropertiesEXT(
+    VkPhysicalDevice physicalDevice,
+        VkSampleCountFlagBits samples,
+        VkMultisamplePropertiesEXT* pMultisampleProperties);
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+    VkResult vkCreateValidationCacheEXT(
+    VkDevice device,
+        const VkValidationCacheCreateInfoEXT* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkValidationCacheEXT* pValidationCache);
+    void vkDestroyValidationCacheEXT(
+    VkDevice device,
+        VkValidationCacheEXT validationCache,
+        const VkAllocationCallbacks* pAllocator);
+    VkResult vkMergeValidationCachesEXT(
+    VkDevice device,
+        VkValidationCacheEXT dstCache,
+        uint32_t srcCacheCount,
+        const VkValidationCacheEXT* pSrcCaches);
+    VkResult vkGetValidationCacheDataEXT(
+    VkDevice device,
+        VkValidationCacheEXT validationCache,
+        size_t* pDataSize,
+        void* pData);
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+    VkResult vkGetMemoryHostPointerPropertiesEXT(
+    VkDevice device,
+        VkExternalMemoryHandleTypeFlagBits handleType,
+        const void* pHostPointer,
+        VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
+#endif
+#ifdef VK_AMD_buffer_marker
+    void vkCmdWriteBufferMarkerAMD(
+    VkCommandBuffer commandBuffer,
+        VkPipelineStageFlagBits pipelineStage,
+        VkBuffer dstBuffer,
+        VkDeviceSize dstOffset,
+        uint32_t marker);
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+    void vkCmdSetCheckpointNV(
+    VkCommandBuffer commandBuffer,
+        const void* pCheckpointMarker);
+    void vkGetQueueCheckpointDataNV(
+    VkQueue queue,
+        uint32_t* pCheckpointDataCount,
+        VkCheckpointDataNV* pCheckpointData);
+#endif
+
+private:
+    class Impl;
+    std::unique_ptr<Impl> mImpl;
+};
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEventHandler.cpp b/system/vulkan_enc/VkEventHandler.cpp
new file mode 100644
index 0000000..0e166f3
--- /dev/null
+++ b/system/vulkan_enc/VkEventHandler.cpp
@@ -0,0 +1,3155 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module VkEventHandler
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "VkEventHandler.h"
+
+
+#include "VkEncoder.h"
+
+
+namespace goldfish_vk {
+
+
+VkEventHandler::VkEventHandler() { }
+VkEventHandler::~VkEventHandler() { }
+#ifdef VK_VERSION_1_0
+VkResult VkEventHandler::on_vkCreateInstance(
+    void*,
+    VkResult,
+    const VkInstanceCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkInstance*)
+{
+    VkResult on_vkCreateInstance_VkResult_return = (VkResult)0;
+    return on_vkCreateInstance_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyInstance(
+    void*,
+    VkInstance,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkEnumeratePhysicalDevices(
+    void*,
+    VkResult,
+    VkInstance,
+    uint32_t*,
+    VkPhysicalDevice*)
+{
+    VkResult on_vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
+    return on_vkEnumeratePhysicalDevices_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFeatures(
+    void*,
+    VkPhysicalDevice,
+    VkPhysicalDeviceFeatures*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFormatProperties(
+    void*,
+    VkPhysicalDevice,
+    VkFormat,
+    VkFormatProperties*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceImageFormatProperties(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkFormat,
+    VkImageType,
+    VkImageTiling,
+    VkImageUsageFlags,
+    VkImageCreateFlags,
+    VkImageFormatProperties*)
+{
+    VkResult on_vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceProperties(
+    void*,
+    VkPhysicalDevice,
+    VkPhysicalDeviceProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceQueueFamilyProperties(
+    void*,
+    VkPhysicalDevice,
+    uint32_t*,
+    VkQueueFamilyProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMemoryProperties(
+    void*,
+    VkPhysicalDevice,
+    VkPhysicalDeviceMemoryProperties*)
+{
+}
+PFN_vkVoidFunction VkEventHandler::on_vkGetInstanceProcAddr(
+    void*,
+    PFN_vkVoidFunction,
+    VkInstance,
+    const char*)
+{
+    PFN_vkVoidFunction on_vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+    return on_vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
+}
+PFN_vkVoidFunction VkEventHandler::on_vkGetDeviceProcAddr(
+    void*,
+    PFN_vkVoidFunction,
+    VkDevice,
+    const char*)
+{
+    PFN_vkVoidFunction on_vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+    return on_vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
+}
+VkResult VkEventHandler::on_vkCreateDevice(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    const VkDeviceCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkDevice*)
+{
+    VkResult on_vkCreateDevice_VkResult_return = (VkResult)0;
+    return on_vkCreateDevice_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDevice(
+    void*,
+    VkDevice,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkEnumerateInstanceExtensionProperties(
+    void*,
+    VkResult,
+    const char*,
+    uint32_t*,
+    VkExtensionProperties*)
+{
+    VkResult on_vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
+    return on_vkEnumerateInstanceExtensionProperties_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEnumerateDeviceExtensionProperties(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    const char*,
+    uint32_t*,
+    VkExtensionProperties*)
+{
+    VkResult on_vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
+    return on_vkEnumerateDeviceExtensionProperties_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEnumerateInstanceLayerProperties(
+    void*,
+    VkResult,
+    uint32_t*,
+    VkLayerProperties*)
+{
+    VkResult on_vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
+    return on_vkEnumerateInstanceLayerProperties_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEnumerateDeviceLayerProperties(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    uint32_t*,
+    VkLayerProperties*)
+{
+    VkResult on_vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
+    return on_vkEnumerateDeviceLayerProperties_VkResult_return;
+}
+void VkEventHandler::on_vkGetDeviceQueue(
+    void*,
+    VkDevice,
+    uint32_t,
+    uint32_t,
+    VkQueue*)
+{
+}
+VkResult VkEventHandler::on_vkQueueSubmit(
+    void*,
+    VkResult,
+    VkQueue,
+    uint32_t,
+    const VkSubmitInfo*,
+    VkFence)
+{
+    VkResult on_vkQueueSubmit_VkResult_return = (VkResult)0;
+    return on_vkQueueSubmit_VkResult_return;
+}
+VkResult VkEventHandler::on_vkQueueWaitIdle(
+    void*,
+    VkResult,
+    VkQueue)
+{
+    VkResult on_vkQueueWaitIdle_VkResult_return = (VkResult)0;
+    return on_vkQueueWaitIdle_VkResult_return;
+}
+VkResult VkEventHandler::on_vkDeviceWaitIdle(
+    void*,
+    VkResult,
+    VkDevice)
+{
+    VkResult on_vkDeviceWaitIdle_VkResult_return = (VkResult)0;
+    return on_vkDeviceWaitIdle_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAllocateMemory(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkMemoryAllocateInfo*,
+    const VkAllocationCallbacks*,
+    VkDeviceMemory*)
+{
+    VkResult on_vkAllocateMemory_VkResult_return = (VkResult)0;
+    return on_vkAllocateMemory_VkResult_return;
+}
+void VkEventHandler::on_vkFreeMemory(
+    void*,
+    VkDevice,
+    VkDeviceMemory,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkMapMemory(
+    void*,
+    VkResult,
+    VkDevice,
+    VkDeviceMemory,
+    VkDeviceSize,
+    VkDeviceSize,
+    VkMemoryMapFlags,
+    void**)
+{
+    VkResult on_vkMapMemory_VkResult_return = (VkResult)0;
+    return on_vkMapMemory_VkResult_return;
+}
+void VkEventHandler::on_vkUnmapMemory(
+    void*,
+    VkDevice,
+    VkDeviceMemory)
+{
+}
+VkResult VkEventHandler::on_vkFlushMappedMemoryRanges(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t,
+    const VkMappedMemoryRange*)
+{
+    VkResult on_vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
+    return on_vkFlushMappedMemoryRanges_VkResult_return;
+}
+VkResult VkEventHandler::on_vkInvalidateMappedMemoryRanges(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t,
+    const VkMappedMemoryRange*)
+{
+    VkResult on_vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
+    return on_vkInvalidateMappedMemoryRanges_VkResult_return;
+}
+void VkEventHandler::on_vkGetDeviceMemoryCommitment(
+    void*,
+    VkDevice,
+    VkDeviceMemory,
+    VkDeviceSize*)
+{
+}
+VkResult VkEventHandler::on_vkBindBufferMemory(
+    void*,
+    VkResult,
+    VkDevice,
+    VkBuffer,
+    VkDeviceMemory,
+    VkDeviceSize)
+{
+    VkResult on_vkBindBufferMemory_VkResult_return = (VkResult)0;
+    return on_vkBindBufferMemory_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindImageMemory(
+    void*,
+    VkResult,
+    VkDevice,
+    VkImage,
+    VkDeviceMemory,
+    VkDeviceSize)
+{
+    VkResult on_vkBindImageMemory_VkResult_return = (VkResult)0;
+    return on_vkBindImageMemory_VkResult_return;
+}
+void VkEventHandler::on_vkGetBufferMemoryRequirements(
+    void*,
+    VkDevice,
+    VkBuffer,
+    VkMemoryRequirements*)
+{
+}
+void VkEventHandler::on_vkGetImageMemoryRequirements(
+    void*,
+    VkDevice,
+    VkImage,
+    VkMemoryRequirements*)
+{
+}
+void VkEventHandler::on_vkGetImageSparseMemoryRequirements(
+    void*,
+    VkDevice,
+    VkImage,
+    uint32_t*,
+    VkSparseImageMemoryRequirements*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceSparseImageFormatProperties(
+    void*,
+    VkPhysicalDevice,
+    VkFormat,
+    VkImageType,
+    VkSampleCountFlagBits,
+    VkImageUsageFlags,
+    VkImageTiling,
+    uint32_t*,
+    VkSparseImageFormatProperties*)
+{
+}
+VkResult VkEventHandler::on_vkQueueBindSparse(
+    void*,
+    VkResult,
+    VkQueue,
+    uint32_t,
+    const VkBindSparseInfo*,
+    VkFence)
+{
+    VkResult on_vkQueueBindSparse_VkResult_return = (VkResult)0;
+    return on_vkQueueBindSparse_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateFence(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkFenceCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkFence*)
+{
+    VkResult on_vkCreateFence_VkResult_return = (VkResult)0;
+    return on_vkCreateFence_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyFence(
+    void*,
+    VkDevice,
+    VkFence,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkResetFences(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t,
+    const VkFence*)
+{
+    VkResult on_vkResetFences_VkResult_return = (VkResult)0;
+    return on_vkResetFences_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetFenceStatus(
+    void*,
+    VkResult,
+    VkDevice,
+    VkFence)
+{
+    VkResult on_vkGetFenceStatus_VkResult_return = (VkResult)0;
+    return on_vkGetFenceStatus_VkResult_return;
+}
+VkResult VkEventHandler::on_vkWaitForFences(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t,
+    const VkFence*,
+    VkBool32,
+    uint64_t)
+{
+    VkResult on_vkWaitForFences_VkResult_return = (VkResult)0;
+    return on_vkWaitForFences_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateSemaphore(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkSemaphoreCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkSemaphore*)
+{
+    VkResult on_vkCreateSemaphore_VkResult_return = (VkResult)0;
+    return on_vkCreateSemaphore_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySemaphore(
+    void*,
+    VkDevice,
+    VkSemaphore,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateEvent(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkEventCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkEvent*)
+{
+    VkResult on_vkCreateEvent_VkResult_return = (VkResult)0;
+    return on_vkCreateEvent_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyEvent(
+    void*,
+    VkDevice,
+    VkEvent,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetEventStatus(
+    void*,
+    VkResult,
+    VkDevice,
+    VkEvent)
+{
+    VkResult on_vkGetEventStatus_VkResult_return = (VkResult)0;
+    return on_vkGetEventStatus_VkResult_return;
+}
+VkResult VkEventHandler::on_vkSetEvent(
+    void*,
+    VkResult,
+    VkDevice,
+    VkEvent)
+{
+    VkResult on_vkSetEvent_VkResult_return = (VkResult)0;
+    return on_vkSetEvent_VkResult_return;
+}
+VkResult VkEventHandler::on_vkResetEvent(
+    void*,
+    VkResult,
+    VkDevice,
+    VkEvent)
+{
+    VkResult on_vkResetEvent_VkResult_return = (VkResult)0;
+    return on_vkResetEvent_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateQueryPool(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkQueryPoolCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkQueryPool*)
+{
+    VkResult on_vkCreateQueryPool_VkResult_return = (VkResult)0;
+    return on_vkCreateQueryPool_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyQueryPool(
+    void*,
+    VkDevice,
+    VkQueryPool,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetQueryPoolResults(
+    void*,
+    VkResult,
+    VkDevice,
+    VkQueryPool,
+    uint32_t,
+    uint32_t,
+    size_t,
+    void*,
+    VkDeviceSize,
+    VkQueryResultFlags)
+{
+    VkResult on_vkGetQueryPoolResults_VkResult_return = (VkResult)0;
+    return on_vkGetQueryPoolResults_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateBuffer(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkBufferCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkBuffer*)
+{
+    VkResult on_vkCreateBuffer_VkResult_return = (VkResult)0;
+    return on_vkCreateBuffer_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyBuffer(
+    void*,
+    VkDevice,
+    VkBuffer,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateBufferView(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkBufferViewCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkBufferView*)
+{
+    VkResult on_vkCreateBufferView_VkResult_return = (VkResult)0;
+    return on_vkCreateBufferView_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyBufferView(
+    void*,
+    VkDevice,
+    VkBufferView,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateImage(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkImageCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkImage*)
+{
+    VkResult on_vkCreateImage_VkResult_return = (VkResult)0;
+    return on_vkCreateImage_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyImage(
+    void*,
+    VkDevice,
+    VkImage,
+    const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkGetImageSubresourceLayout(
+    void*,
+    VkDevice,
+    VkImage,
+    const VkImageSubresource*,
+    VkSubresourceLayout*)
+{
+}
+VkResult VkEventHandler::on_vkCreateImageView(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkImageViewCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkImageView*)
+{
+    VkResult on_vkCreateImageView_VkResult_return = (VkResult)0;
+    return on_vkCreateImageView_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyImageView(
+    void*,
+    VkDevice,
+    VkImageView,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateShaderModule(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkShaderModuleCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkShaderModule*)
+{
+    VkResult on_vkCreateShaderModule_VkResult_return = (VkResult)0;
+    return on_vkCreateShaderModule_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyShaderModule(
+    void*,
+    VkDevice,
+    VkShaderModule,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreatePipelineCache(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkPipelineCacheCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkPipelineCache*)
+{
+    VkResult on_vkCreatePipelineCache_VkResult_return = (VkResult)0;
+    return on_vkCreatePipelineCache_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyPipelineCache(
+    void*,
+    VkDevice,
+    VkPipelineCache,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetPipelineCacheData(
+    void*,
+    VkResult,
+    VkDevice,
+    VkPipelineCache,
+    size_t*,
+    void*)
+{
+    VkResult on_vkGetPipelineCacheData_VkResult_return = (VkResult)0;
+    return on_vkGetPipelineCacheData_VkResult_return;
+}
+VkResult VkEventHandler::on_vkMergePipelineCaches(
+    void*,
+    VkResult,
+    VkDevice,
+    VkPipelineCache,
+    uint32_t,
+    const VkPipelineCache*)
+{
+    VkResult on_vkMergePipelineCaches_VkResult_return = (VkResult)0;
+    return on_vkMergePipelineCaches_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateGraphicsPipelines(
+    void*,
+    VkResult,
+    VkDevice,
+    VkPipelineCache,
+    uint32_t,
+    const VkGraphicsPipelineCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkPipeline*)
+{
+    VkResult on_vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
+    return on_vkCreateGraphicsPipelines_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateComputePipelines(
+    void*,
+    VkResult,
+    VkDevice,
+    VkPipelineCache,
+    uint32_t,
+    const VkComputePipelineCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkPipeline*)
+{
+    VkResult on_vkCreateComputePipelines_VkResult_return = (VkResult)0;
+    return on_vkCreateComputePipelines_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyPipeline(
+    void*,
+    VkDevice,
+    VkPipeline,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreatePipelineLayout(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkPipelineLayoutCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkPipelineLayout*)
+{
+    VkResult on_vkCreatePipelineLayout_VkResult_return = (VkResult)0;
+    return on_vkCreatePipelineLayout_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyPipelineLayout(
+    void*,
+    VkDevice,
+    VkPipelineLayout,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateSampler(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkSamplerCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkSampler*)
+{
+    VkResult on_vkCreateSampler_VkResult_return = (VkResult)0;
+    return on_vkCreateSampler_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySampler(
+    void*,
+    VkDevice,
+    VkSampler,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDescriptorSetLayout(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkDescriptorSetLayoutCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkDescriptorSetLayout*)
+{
+    VkResult on_vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
+    return on_vkCreateDescriptorSetLayout_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorSetLayout(
+    void*,
+    VkDevice,
+    VkDescriptorSetLayout,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDescriptorPool(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkDescriptorPoolCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkDescriptorPool*)
+{
+    VkResult on_vkCreateDescriptorPool_VkResult_return = (VkResult)0;
+    return on_vkCreateDescriptorPool_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorPool(
+    void*,
+    VkDevice,
+    VkDescriptorPool,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkResetDescriptorPool(
+    void*,
+    VkResult,
+    VkDevice,
+    VkDescriptorPool,
+    VkDescriptorPoolResetFlags)
+{
+    VkResult on_vkResetDescriptorPool_VkResult_return = (VkResult)0;
+    return on_vkResetDescriptorPool_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAllocateDescriptorSets(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkDescriptorSetAllocateInfo*,
+    VkDescriptorSet*)
+{
+    VkResult on_vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
+    return on_vkAllocateDescriptorSets_VkResult_return;
+}
+VkResult VkEventHandler::on_vkFreeDescriptorSets(
+    void*,
+    VkResult,
+    VkDevice,
+    VkDescriptorPool,
+    uint32_t,
+    const VkDescriptorSet*)
+{
+    VkResult on_vkFreeDescriptorSets_VkResult_return = (VkResult)0;
+    return on_vkFreeDescriptorSets_VkResult_return;
+}
+void VkEventHandler::on_vkUpdateDescriptorSets(
+    void*,
+    VkDevice,
+    uint32_t,
+    const VkWriteDescriptorSet*,
+    uint32_t,
+    const VkCopyDescriptorSet*)
+{
+}
+VkResult VkEventHandler::on_vkCreateFramebuffer(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkFramebufferCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkFramebuffer*)
+{
+    VkResult on_vkCreateFramebuffer_VkResult_return = (VkResult)0;
+    return on_vkCreateFramebuffer_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyFramebuffer(
+    void*,
+    VkDevice,
+    VkFramebuffer,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateRenderPass(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkRenderPassCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkRenderPass*)
+{
+    VkResult on_vkCreateRenderPass_VkResult_return = (VkResult)0;
+    return on_vkCreateRenderPass_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyRenderPass(
+    void*,
+    VkDevice,
+    VkRenderPass,
+    const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkGetRenderAreaGranularity(
+    void*,
+    VkDevice,
+    VkRenderPass,
+    VkExtent2D*)
+{
+}
+VkResult VkEventHandler::on_vkCreateCommandPool(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkCommandPoolCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkCommandPool*)
+{
+    VkResult on_vkCreateCommandPool_VkResult_return = (VkResult)0;
+    return on_vkCreateCommandPool_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyCommandPool(
+    void*,
+    VkDevice,
+    VkCommandPool,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkResetCommandPool(
+    void*,
+    VkResult,
+    VkDevice,
+    VkCommandPool,
+    VkCommandPoolResetFlags)
+{
+    VkResult on_vkResetCommandPool_VkResult_return = (VkResult)0;
+    return on_vkResetCommandPool_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAllocateCommandBuffers(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkCommandBufferAllocateInfo*,
+    VkCommandBuffer*)
+{
+    VkResult on_vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
+    return on_vkAllocateCommandBuffers_VkResult_return;
+}
+void VkEventHandler::on_vkFreeCommandBuffers(
+    void*,
+    VkDevice,
+    VkCommandPool,
+    uint32_t,
+    const VkCommandBuffer*)
+{
+}
+VkResult VkEventHandler::on_vkBeginCommandBuffer(
+    void*,
+    VkResult,
+    VkCommandBuffer,
+    const VkCommandBufferBeginInfo*)
+{
+    VkResult on_vkBeginCommandBuffer_VkResult_return = (VkResult)0;
+    return on_vkBeginCommandBuffer_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEndCommandBuffer(
+    void*,
+    VkResult,
+    VkCommandBuffer)
+{
+    VkResult on_vkEndCommandBuffer_VkResult_return = (VkResult)0;
+    return on_vkEndCommandBuffer_VkResult_return;
+}
+VkResult VkEventHandler::on_vkResetCommandBuffer(
+    void*,
+    VkResult,
+    VkCommandBuffer,
+    VkCommandBufferResetFlags)
+{
+    VkResult on_vkResetCommandBuffer_VkResult_return = (VkResult)0;
+    return on_vkResetCommandBuffer_VkResult_return;
+}
+void VkEventHandler::on_vkCmdBindPipeline(
+    void*,
+    VkCommandBuffer,
+    VkPipelineBindPoint,
+    VkPipeline)
+{
+}
+void VkEventHandler::on_vkCmdSetViewport(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    uint32_t,
+    const VkViewport*)
+{
+}
+void VkEventHandler::on_vkCmdSetScissor(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    uint32_t,
+    const VkRect2D*)
+{
+}
+void VkEventHandler::on_vkCmdSetLineWidth(
+    void*,
+    VkCommandBuffer,
+    float)
+{
+}
+void VkEventHandler::on_vkCmdSetDepthBias(
+    void*,
+    VkCommandBuffer,
+    float,
+    float,
+    float)
+{
+}
+void VkEventHandler::on_vkCmdSetBlendConstants(
+    void*,
+    VkCommandBuffer,
+    const float)
+{
+}
+void VkEventHandler::on_vkCmdSetDepthBounds(
+    void*,
+    VkCommandBuffer,
+    float,
+    float)
+{
+}
+void VkEventHandler::on_vkCmdSetStencilCompareMask(
+    void*,
+    VkCommandBuffer,
+    VkStencilFaceFlags,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdSetStencilWriteMask(
+    void*,
+    VkCommandBuffer,
+    VkStencilFaceFlags,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdSetStencilReference(
+    void*,
+    VkCommandBuffer,
+    VkStencilFaceFlags,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdBindDescriptorSets(
+    void*,
+    VkCommandBuffer,
+    VkPipelineBindPoint,
+    VkPipelineLayout,
+    uint32_t,
+    uint32_t,
+    const VkDescriptorSet*,
+    uint32_t,
+    const uint32_t*)
+{
+}
+void VkEventHandler::on_vkCmdBindIndexBuffer(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkDeviceSize,
+    VkIndexType)
+{
+}
+void VkEventHandler::on_vkCmdBindVertexBuffers(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    uint32_t,
+    const VkBuffer*,
+    const VkDeviceSize*)
+{
+}
+void VkEventHandler::on_vkCmdDraw(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    uint32_t,
+    uint32_t,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexed(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    uint32_t,
+    uint32_t,
+    int32_t,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndirect(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkDeviceSize,
+    uint32_t,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexedIndirect(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkDeviceSize,
+    uint32_t,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatch(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    uint32_t,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatchIndirect(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkDeviceSize)
+{
+}
+void VkEventHandler::on_vkCmdCopyBuffer(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkBuffer,
+    uint32_t,
+    const VkBufferCopy*)
+{
+}
+void VkEventHandler::on_vkCmdCopyImage(
+    void*,
+    VkCommandBuffer,
+    VkImage,
+    VkImageLayout,
+    VkImage,
+    VkImageLayout,
+    uint32_t,
+    const VkImageCopy*)
+{
+}
+void VkEventHandler::on_vkCmdBlitImage(
+    void*,
+    VkCommandBuffer,
+    VkImage,
+    VkImageLayout,
+    VkImage,
+    VkImageLayout,
+    uint32_t,
+    const VkImageBlit*,
+    VkFilter)
+{
+}
+void VkEventHandler::on_vkCmdCopyBufferToImage(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkImage,
+    VkImageLayout,
+    uint32_t,
+    const VkBufferImageCopy*)
+{
+}
+void VkEventHandler::on_vkCmdCopyImageToBuffer(
+    void*,
+    VkCommandBuffer,
+    VkImage,
+    VkImageLayout,
+    VkBuffer,
+    uint32_t,
+    const VkBufferImageCopy*)
+{
+}
+void VkEventHandler::on_vkCmdUpdateBuffer(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkDeviceSize,
+    VkDeviceSize,
+    const void*)
+{
+}
+void VkEventHandler::on_vkCmdFillBuffer(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkDeviceSize,
+    VkDeviceSize,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdClearColorImage(
+    void*,
+    VkCommandBuffer,
+    VkImage,
+    VkImageLayout,
+    const VkClearColorValue*,
+    uint32_t,
+    const VkImageSubresourceRange*)
+{
+}
+void VkEventHandler::on_vkCmdClearDepthStencilImage(
+    void*,
+    VkCommandBuffer,
+    VkImage,
+    VkImageLayout,
+    const VkClearDepthStencilValue*,
+    uint32_t,
+    const VkImageSubresourceRange*)
+{
+}
+void VkEventHandler::on_vkCmdClearAttachments(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    const VkClearAttachment*,
+    uint32_t,
+    const VkClearRect*)
+{
+}
+void VkEventHandler::on_vkCmdResolveImage(
+    void*,
+    VkCommandBuffer,
+    VkImage,
+    VkImageLayout,
+    VkImage,
+    VkImageLayout,
+    uint32_t,
+    const VkImageResolve*)
+{
+}
+void VkEventHandler::on_vkCmdSetEvent(
+    void*,
+    VkCommandBuffer,
+    VkEvent,
+    VkPipelineStageFlags)
+{
+}
+void VkEventHandler::on_vkCmdResetEvent(
+    void*,
+    VkCommandBuffer,
+    VkEvent,
+    VkPipelineStageFlags)
+{
+}
+void VkEventHandler::on_vkCmdWaitEvents(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    const VkEvent*,
+    VkPipelineStageFlags,
+    VkPipelineStageFlags,
+    uint32_t,
+    const VkMemoryBarrier*,
+    uint32_t,
+    const VkBufferMemoryBarrier*,
+    uint32_t,
+    const VkImageMemoryBarrier*)
+{
+}
+void VkEventHandler::on_vkCmdPipelineBarrier(
+    void*,
+    VkCommandBuffer,
+    VkPipelineStageFlags,
+    VkPipelineStageFlags,
+    VkDependencyFlags,
+    uint32_t,
+    const VkMemoryBarrier*,
+    uint32_t,
+    const VkBufferMemoryBarrier*,
+    uint32_t,
+    const VkImageMemoryBarrier*)
+{
+}
+void VkEventHandler::on_vkCmdBeginQuery(
+    void*,
+    VkCommandBuffer,
+    VkQueryPool,
+    uint32_t,
+    VkQueryControlFlags)
+{
+}
+void VkEventHandler::on_vkCmdEndQuery(
+    void*,
+    VkCommandBuffer,
+    VkQueryPool,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdResetQueryPool(
+    void*,
+    VkCommandBuffer,
+    VkQueryPool,
+    uint32_t,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdWriteTimestamp(
+    void*,
+    VkCommandBuffer,
+    VkPipelineStageFlagBits,
+    VkQueryPool,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdCopyQueryPoolResults(
+    void*,
+    VkCommandBuffer,
+    VkQueryPool,
+    uint32_t,
+    uint32_t,
+    VkBuffer,
+    VkDeviceSize,
+    VkDeviceSize,
+    VkQueryResultFlags)
+{
+}
+void VkEventHandler::on_vkCmdPushConstants(
+    void*,
+    VkCommandBuffer,
+    VkPipelineLayout,
+    VkShaderStageFlags,
+    uint32_t,
+    uint32_t,
+    const void*)
+{
+}
+void VkEventHandler::on_vkCmdBeginRenderPass(
+    void*,
+    VkCommandBuffer,
+    const VkRenderPassBeginInfo*,
+    VkSubpassContents)
+{
+}
+void VkEventHandler::on_vkCmdNextSubpass(
+    void*,
+    VkCommandBuffer,
+    VkSubpassContents)
+{
+}
+void VkEventHandler::on_vkCmdEndRenderPass(
+    void*,
+    VkCommandBuffer)
+{
+}
+void VkEventHandler::on_vkCmdExecuteCommands(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    const VkCommandBuffer*)
+{
+}
+#endif
+#ifdef VK_VERSION_1_1
+VkResult VkEventHandler::on_vkEnumerateInstanceVersion(
+    void*,
+    VkResult,
+    uint32_t*)
+{
+    VkResult on_vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
+    return on_vkEnumerateInstanceVersion_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindBufferMemory2(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t,
+    const VkBindBufferMemoryInfo*)
+{
+    VkResult on_vkBindBufferMemory2_VkResult_return = (VkResult)0;
+    return on_vkBindBufferMemory2_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindImageMemory2(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t,
+    const VkBindImageMemoryInfo*)
+{
+    VkResult on_vkBindImageMemory2_VkResult_return = (VkResult)0;
+    return on_vkBindImageMemory2_VkResult_return;
+}
+void VkEventHandler::on_vkGetDeviceGroupPeerMemoryFeatures(
+    void*,
+    VkDevice,
+    uint32_t,
+    uint32_t,
+    uint32_t,
+    VkPeerMemoryFeatureFlags*)
+{
+}
+void VkEventHandler::on_vkCmdSetDeviceMask(
+    void*,
+    VkCommandBuffer,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatchBase(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    uint32_t,
+    uint32_t,
+    uint32_t,
+    uint32_t,
+    uint32_t)
+{
+}
+VkResult VkEventHandler::on_vkEnumeratePhysicalDeviceGroups(
+    void*,
+    VkResult,
+    VkInstance,
+    uint32_t*,
+    VkPhysicalDeviceGroupProperties*)
+{
+    VkResult on_vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
+    return on_vkEnumeratePhysicalDeviceGroups_VkResult_return;
+}
+void VkEventHandler::on_vkGetImageMemoryRequirements2(
+    void*,
+    VkDevice,
+    const VkImageMemoryRequirementsInfo2*,
+    VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetBufferMemoryRequirements2(
+    void*,
+    VkDevice,
+    const VkBufferMemoryRequirementsInfo2*,
+    VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetImageSparseMemoryRequirements2(
+    void*,
+    VkDevice,
+    const VkImageSparseMemoryRequirementsInfo2*,
+    uint32_t*,
+    VkSparseImageMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFeatures2(
+    void*,
+    VkPhysicalDevice,
+    VkPhysicalDeviceFeatures2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceProperties2(
+    void*,
+    VkPhysicalDevice,
+    VkPhysicalDeviceProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFormatProperties2(
+    void*,
+    VkPhysicalDevice,
+    VkFormat,
+    VkFormatProperties2*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceImageFormatProperties2(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2*,
+    VkImageFormatProperties2*)
+{
+    VkResult on_vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceQueueFamilyProperties2(
+    void*,
+    VkPhysicalDevice,
+    uint32_t*,
+    VkQueueFamilyProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMemoryProperties2(
+    void*,
+    VkPhysicalDevice,
+    VkPhysicalDeviceMemoryProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceSparseImageFormatProperties2(
+    void*,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceSparseImageFormatInfo2*,
+    uint32_t*,
+    VkSparseImageFormatProperties2*)
+{
+}
+void VkEventHandler::on_vkTrimCommandPool(
+    void*,
+    VkDevice,
+    VkCommandPool,
+    VkCommandPoolTrimFlags)
+{
+}
+void VkEventHandler::on_vkGetDeviceQueue2(
+    void*,
+    VkDevice,
+    const VkDeviceQueueInfo2*,
+    VkQueue*)
+{
+}
+VkResult VkEventHandler::on_vkCreateSamplerYcbcrConversion(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkSamplerYcbcrConversionCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkSamplerYcbcrConversion*)
+{
+    VkResult on_vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
+    return on_vkCreateSamplerYcbcrConversion_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySamplerYcbcrConversion(
+    void*,
+    VkDevice,
+    VkSamplerYcbcrConversion,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDescriptorUpdateTemplate(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkDescriptorUpdateTemplateCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkDescriptorUpdateTemplate*)
+{
+    VkResult on_vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
+    return on_vkCreateDescriptorUpdateTemplate_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorUpdateTemplate(
+    void*,
+    VkDevice,
+    VkDescriptorUpdateTemplate,
+    const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkUpdateDescriptorSetWithTemplate(
+    void*,
+    VkDevice,
+    VkDescriptorSet,
+    VkDescriptorUpdateTemplate,
+    const void*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceExternalBufferProperties(
+    void*,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceExternalBufferInfo*,
+    VkExternalBufferProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceExternalFenceProperties(
+    void*,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceExternalFenceInfo*,
+    VkExternalFenceProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceExternalSemaphoreProperties(
+    void*,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceExternalSemaphoreInfo*,
+    VkExternalSemaphoreProperties*)
+{
+}
+void VkEventHandler::on_vkGetDescriptorSetLayoutSupport(
+    void*,
+    VkDevice,
+    const VkDescriptorSetLayoutCreateInfo*,
+    VkDescriptorSetLayoutSupport*)
+{
+}
+#endif
+#ifdef VK_KHR_surface
+void VkEventHandler::on_vkDestroySurfaceKHR(
+    void*,
+    VkInstance,
+    VkSurfaceKHR,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceSupportKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    uint32_t,
+    VkSurfaceKHR,
+    VkBool32*)
+{
+    VkResult on_vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkSurfaceKHR,
+    VkSurfaceCapabilitiesKHR*)
+{
+    VkResult on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceFormatsKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkSurfaceKHR,
+    uint32_t*,
+    VkSurfaceFormatKHR*)
+{
+    VkResult on_vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfacePresentModesKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkSurfaceKHR,
+    uint32_t*,
+    VkPresentModeKHR*)
+{
+    VkResult on_vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_swapchain
+VkResult VkEventHandler::on_vkCreateSwapchainKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkSwapchainCreateInfoKHR*,
+    const VkAllocationCallbacks*,
+    VkSwapchainKHR*)
+{
+    VkResult on_vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateSwapchainKHR_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySwapchainKHR(
+    void*,
+    VkDevice,
+    VkSwapchainKHR,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetSwapchainImagesKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    VkSwapchainKHR,
+    uint32_t*,
+    VkImage*)
+{
+    VkResult on_vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetSwapchainImagesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAcquireNextImageKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    VkSwapchainKHR,
+    uint64_t,
+    VkSemaphore,
+    VkFence,
+    uint32_t*)
+{
+    VkResult on_vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
+    return on_vkAcquireNextImageKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkQueuePresentKHR(
+    void*,
+    VkResult,
+    VkQueue,
+    const VkPresentInfoKHR*)
+{
+    VkResult on_vkQueuePresentKHR_VkResult_return = (VkResult)0;
+    return on_vkQueuePresentKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDeviceGroupPresentCapabilitiesKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    VkDeviceGroupPresentCapabilitiesKHR*)
+{
+    VkResult on_vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDeviceGroupSurfacePresentModesKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    VkSurfaceKHR,
+    VkDeviceGroupPresentModeFlagsKHR*)
+{
+    VkResult on_vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDevicePresentRectanglesKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkSurfaceKHR,
+    uint32_t*,
+    VkRect2D*)
+{
+    VkResult on_vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAcquireNextImage2KHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkAcquireNextImageInfoKHR*,
+    uint32_t*)
+{
+    VkResult on_vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
+    return on_vkAcquireNextImage2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayPropertiesKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    uint32_t*,
+    VkDisplayPropertiesKHR*)
+{
+    VkResult on_vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    uint32_t*,
+    VkDisplayPlanePropertiesKHR*)
+{
+    VkResult on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayPlaneSupportedDisplaysKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    uint32_t,
+    uint32_t*,
+    VkDisplayKHR*)
+{
+    VkResult on_vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
+    return on_vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayModePropertiesKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkDisplayKHR,
+    uint32_t*,
+    VkDisplayModePropertiesKHR*)
+{
+    VkResult on_vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetDisplayModePropertiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateDisplayModeKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkDisplayKHR,
+    const VkDisplayModeCreateInfoKHR*,
+    const VkAllocationCallbacks*,
+    VkDisplayModeKHR*)
+{
+    VkResult on_vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateDisplayModeKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayPlaneCapabilitiesKHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkDisplayModeKHR,
+    uint32_t,
+    VkDisplayPlaneCapabilitiesKHR*)
+{
+    VkResult on_vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateDisplayPlaneSurfaceKHR(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkDisplaySurfaceCreateInfoKHR*,
+    const VkAllocationCallbacks*,
+    VkSurfaceKHR*)
+{
+    VkResult on_vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display_swapchain
+VkResult VkEventHandler::on_vkCreateSharedSwapchainsKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t,
+    const VkSwapchainCreateInfoKHR*,
+    const VkAllocationCallbacks*,
+    VkSwapchainKHR*)
+{
+    VkResult on_vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateSharedSwapchainsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_xlib_surface
+VkResult VkEventHandler::on_vkCreateXlibSurfaceKHR(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkXlibSurfaceCreateInfoKHR*,
+    const VkAllocationCallbacks*,
+    VkSurfaceKHR*)
+{
+    VkResult on_vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateXlibSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    void*,
+    VkBool32,
+    VkPhysicalDevice,
+    uint32_t,
+    Display*,
+    VisualID)
+{
+    VkBool32 on_vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    return on_vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_xcb_surface
+VkResult VkEventHandler::on_vkCreateXcbSurfaceKHR(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkXcbSurfaceCreateInfoKHR*,
+    const VkAllocationCallbacks*,
+    VkSurfaceKHR*)
+{
+    VkResult on_vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateXcbSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceXcbPresentationSupportKHR(
+    void*,
+    VkBool32,
+    VkPhysicalDevice,
+    uint32_t,
+    xcb_connection_t*,
+    xcb_visualid_t)
+{
+    VkBool32 on_vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    return on_vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_wayland_surface
+VkResult VkEventHandler::on_vkCreateWaylandSurfaceKHR(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkWaylandSurfaceCreateInfoKHR*,
+    const VkAllocationCallbacks*,
+    VkSurfaceKHR*)
+{
+    VkResult on_vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateWaylandSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+    void*,
+    VkBool32,
+    VkPhysicalDevice,
+    uint32_t,
+    wl_display*)
+{
+    VkBool32 on_vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    return on_vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_mir_surface
+VkResult VkEventHandler::on_vkCreateMirSurfaceKHR(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkMirSurfaceCreateInfoKHR*,
+    const VkAllocationCallbacks*,
+    VkSurfaceKHR*)
+{
+    VkResult on_vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateMirSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceMirPresentationSupportKHR(
+    void*,
+    VkBool32,
+    VkPhysicalDevice,
+    uint32_t,
+    MirConnection*)
+{
+    VkBool32 on_vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    return on_vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_android_surface
+VkResult VkEventHandler::on_vkCreateAndroidSurfaceKHR(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkAndroidSurfaceCreateInfoKHR*,
+    const VkAllocationCallbacks*,
+    VkSurfaceKHR*)
+{
+    VkResult on_vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateAndroidSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_surface
+VkResult VkEventHandler::on_vkCreateWin32SurfaceKHR(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkWin32SurfaceCreateInfoKHR*,
+    const VkAllocationCallbacks*,
+    VkSurfaceKHR*)
+{
+    VkResult on_vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateWin32SurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceWin32PresentationSupportKHR(
+    void*,
+    VkBool32,
+    VkPhysicalDevice,
+    uint32_t)
+{
+    VkBool32 on_vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
+    return on_vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+void VkEventHandler::on_vkGetPhysicalDeviceFeatures2KHR(
+    void*,
+    VkPhysicalDevice,
+    VkPhysicalDeviceFeatures2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceProperties2KHR(
+    void*,
+    VkPhysicalDevice,
+    VkPhysicalDeviceProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFormatProperties2KHR(
+    void*,
+    VkPhysicalDevice,
+    VkFormat,
+    VkFormatProperties2*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceImageFormatProperties2KHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2*,
+    VkImageFormatProperties2*)
+{
+    VkResult on_vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+    void*,
+    VkPhysicalDevice,
+    uint32_t*,
+    VkQueueFamilyProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMemoryProperties2KHR(
+    void*,
+    VkPhysicalDevice,
+    VkPhysicalDeviceMemoryProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+    void*,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceSparseImageFormatInfo2*,
+    uint32_t*,
+    VkSparseImageFormatProperties2*)
+{
+}
+#endif
+#ifdef VK_KHR_device_group
+void VkEventHandler::on_vkGetDeviceGroupPeerMemoryFeaturesKHR(
+    void*,
+    VkDevice,
+    uint32_t,
+    uint32_t,
+    uint32_t,
+    VkPeerMemoryFeatureFlags*)
+{
+}
+void VkEventHandler::on_vkCmdSetDeviceMaskKHR(
+    void*,
+    VkCommandBuffer,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatchBaseKHR(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    uint32_t,
+    uint32_t,
+    uint32_t,
+    uint32_t,
+    uint32_t)
+{
+}
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+void VkEventHandler::on_vkTrimCommandPoolKHR(
+    void*,
+    VkDevice,
+    VkCommandPool,
+    VkCommandPoolTrimFlags)
+{
+}
+#endif
+#ifdef VK_KHR_device_group_creation
+VkResult VkEventHandler::on_vkEnumeratePhysicalDeviceGroupsKHR(
+    void*,
+    VkResult,
+    VkInstance,
+    uint32_t*,
+    VkPhysicalDeviceGroupProperties*)
+{
+    VkResult on_vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
+    return on_vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+void VkEventHandler::on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+    void*,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceExternalBufferInfo*,
+    VkExternalBufferProperties*)
+{
+}
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+VkResult VkEventHandler::on_vkGetMemoryWin32HandleKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkMemoryGetWin32HandleInfoKHR*,
+    HANDLE*)
+{
+    VkResult on_vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
+    return on_vkGetMemoryWin32HandleKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetMemoryWin32HandlePropertiesKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    VkExternalMemoryHandleTypeFlagBits,
+    HANDLE,
+    VkMemoryWin32HandlePropertiesKHR*)
+{
+    VkResult on_vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_fd
+VkResult VkEventHandler::on_vkGetMemoryFdKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkMemoryGetFdInfoKHR*,
+    int*)
+{
+    VkResult on_vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
+    return on_vkGetMemoryFdKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetMemoryFdPropertiesKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    VkExternalMemoryHandleTypeFlagBits,
+    int,
+    VkMemoryFdPropertiesKHR*)
+{
+    VkResult on_vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
+    return on_vkGetMemoryFdPropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+void VkEventHandler::on_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+    void*,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceExternalSemaphoreInfo*,
+    VkExternalSemaphoreProperties*)
+{
+}
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+VkResult VkEventHandler::on_vkImportSemaphoreWin32HandleKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkImportSemaphoreWin32HandleInfoKHR*)
+{
+    VkResult on_vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+    return on_vkImportSemaphoreWin32HandleKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetSemaphoreWin32HandleKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkSemaphoreGetWin32HandleInfoKHR*,
+    HANDLE*)
+{
+    VkResult on_vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+    return on_vkGetSemaphoreWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+VkResult VkEventHandler::on_vkImportSemaphoreFdKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkImportSemaphoreFdInfoKHR*)
+{
+    VkResult on_vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
+    return on_vkImportSemaphoreFdKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetSemaphoreFdKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkSemaphoreGetFdInfoKHR*,
+    int*)
+{
+    VkResult on_vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
+    return on_vkGetSemaphoreFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_push_descriptor
+void VkEventHandler::on_vkCmdPushDescriptorSetKHR(
+    void*,
+    VkCommandBuffer,
+    VkPipelineBindPoint,
+    VkPipelineLayout,
+    uint32_t,
+    uint32_t,
+    const VkWriteDescriptorSet*)
+{
+}
+void VkEventHandler::on_vkCmdPushDescriptorSetWithTemplateKHR(
+    void*,
+    VkCommandBuffer,
+    VkDescriptorUpdateTemplate,
+    VkPipelineLayout,
+    uint32_t,
+    const void*)
+{
+}
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+VkResult VkEventHandler::on_vkCreateDescriptorUpdateTemplateKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkDescriptorUpdateTemplateCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkDescriptorUpdateTemplate*)
+{
+    VkResult on_vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorUpdateTemplateKHR(
+    void*,
+    VkDevice,
+    VkDescriptorUpdateTemplate,
+    const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkUpdateDescriptorSetWithTemplateKHR(
+    void*,
+    VkDevice,
+    VkDescriptorSet,
+    VkDescriptorUpdateTemplate,
+    const void*)
+{
+}
+#endif
+#ifdef VK_KHR_create_renderpass2
+VkResult VkEventHandler::on_vkCreateRenderPass2KHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkRenderPassCreateInfo2KHR*,
+    const VkAllocationCallbacks*,
+    VkRenderPass*)
+{
+    VkResult on_vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
+    return on_vkCreateRenderPass2KHR_VkResult_return;
+}
+void VkEventHandler::on_vkCmdBeginRenderPass2KHR(
+    void*,
+    VkCommandBuffer,
+    const VkRenderPassBeginInfo*,
+    const VkSubpassBeginInfoKHR*)
+{
+}
+void VkEventHandler::on_vkCmdNextSubpass2KHR(
+    void*,
+    VkCommandBuffer,
+    const VkSubpassBeginInfoKHR*,
+    const VkSubpassEndInfoKHR*)
+{
+}
+void VkEventHandler::on_vkCmdEndRenderPass2KHR(
+    void*,
+    VkCommandBuffer,
+    const VkSubpassEndInfoKHR*)
+{
+}
+#endif
+#ifdef VK_KHR_shared_presentable_image
+VkResult VkEventHandler::on_vkGetSwapchainStatusKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    VkSwapchainKHR)
+{
+    VkResult on_vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
+    return on_vkGetSwapchainStatusKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+void VkEventHandler::on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+    void*,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceExternalFenceInfo*,
+    VkExternalFenceProperties*)
+{
+}
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+VkResult VkEventHandler::on_vkImportFenceWin32HandleKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkImportFenceWin32HandleInfoKHR*)
+{
+    VkResult on_vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+    return on_vkImportFenceWin32HandleKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetFenceWin32HandleKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkFenceGetWin32HandleInfoKHR*,
+    HANDLE*)
+{
+    VkResult on_vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+    return on_vkGetFenceWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_fd
+VkResult VkEventHandler::on_vkImportFenceFdKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkImportFenceFdInfoKHR*)
+{
+    VkResult on_vkImportFenceFdKHR_VkResult_return = (VkResult)0;
+    return on_vkImportFenceFdKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetFenceFdKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkFenceGetFdInfoKHR*,
+    int*)
+{
+    VkResult on_vkGetFenceFdKHR_VkResult_return = (VkResult)0;
+    return on_vkGetFenceFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR*,
+    VkSurfaceCapabilities2KHR*)
+{
+    VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceFormats2KHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR*,
+    uint32_t*,
+    VkSurfaceFormat2KHR*)
+{
+    VkResult on_vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayProperties2KHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    uint32_t*,
+    VkDisplayProperties2KHR*)
+{
+    VkResult on_vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    uint32_t*,
+    VkDisplayPlaneProperties2KHR*)
+{
+    VkResult on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayModeProperties2KHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkDisplayKHR,
+    uint32_t*,
+    VkDisplayModeProperties2KHR*)
+{
+    VkResult on_vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
+    return on_vkGetDisplayModeProperties2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayPlaneCapabilities2KHR(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    const VkDisplayPlaneInfo2KHR*,
+    VkDisplayPlaneCapabilities2KHR*)
+{
+    VkResult on_vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
+    return on_vkGetDisplayPlaneCapabilities2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+void VkEventHandler::on_vkGetImageMemoryRequirements2KHR(
+    void*,
+    VkDevice,
+    const VkImageMemoryRequirementsInfo2*,
+    VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetBufferMemoryRequirements2KHR(
+    void*,
+    VkDevice,
+    const VkBufferMemoryRequirementsInfo2*,
+    VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetImageSparseMemoryRequirements2KHR(
+    void*,
+    VkDevice,
+    const VkImageSparseMemoryRequirementsInfo2*,
+    uint32_t*,
+    VkSparseImageMemoryRequirements2*)
+{
+}
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+VkResult VkEventHandler::on_vkCreateSamplerYcbcrConversionKHR(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkSamplerYcbcrConversionCreateInfo*,
+    const VkAllocationCallbacks*,
+    VkSamplerYcbcrConversion*)
+{
+    VkResult on_vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
+    return on_vkCreateSamplerYcbcrConversionKHR_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySamplerYcbcrConversionKHR(
+    void*,
+    VkDevice,
+    VkSamplerYcbcrConversion,
+    const VkAllocationCallbacks*)
+{
+}
+#endif
+#ifdef VK_KHR_bind_memory2
+VkResult VkEventHandler::on_vkBindBufferMemory2KHR(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t,
+    const VkBindBufferMemoryInfo*)
+{
+    VkResult on_vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
+    return on_vkBindBufferMemory2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindImageMemory2KHR(
+    void*,
+    VkResult,
+    VkDevice,
+    uint32_t,
+    const VkBindImageMemoryInfo*)
+{
+    VkResult on_vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
+    return on_vkBindImageMemory2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance3
+void VkEventHandler::on_vkGetDescriptorSetLayoutSupportKHR(
+    void*,
+    VkDevice,
+    const VkDescriptorSetLayoutCreateInfo*,
+    VkDescriptorSetLayoutSupport*)
+{
+}
+#endif
+#ifdef VK_KHR_draw_indirect_count
+void VkEventHandler::on_vkCmdDrawIndirectCountKHR(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkDeviceSize,
+    VkBuffer,
+    VkDeviceSize,
+    uint32_t,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexedIndirectCountKHR(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkDeviceSize,
+    VkBuffer,
+    VkDeviceSize,
+    uint32_t,
+    uint32_t)
+{
+}
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+VkResult VkEventHandler::on_vkGetSwapchainGrallocUsageANDROID(
+    void*,
+    VkResult,
+    VkDevice,
+    VkFormat,
+    VkImageUsageFlags,
+    int*)
+{
+    VkResult on_vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
+    return on_vkGetSwapchainGrallocUsageANDROID_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAcquireImageANDROID(
+    void*,
+    VkResult,
+    VkDevice,
+    VkImage,
+    int,
+    VkSemaphore,
+    VkFence)
+{
+    VkResult on_vkAcquireImageANDROID_VkResult_return = (VkResult)0;
+    return on_vkAcquireImageANDROID_VkResult_return;
+}
+VkResult VkEventHandler::on_vkQueueSignalReleaseImageANDROID(
+    void*,
+    VkResult,
+    VkQueue,
+    uint32_t,
+    const VkSemaphore*,
+    VkImage,
+    int*)
+{
+    VkResult on_vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
+    return on_vkQueueSignalReleaseImageANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_debug_report
+VkResult VkEventHandler::on_vkCreateDebugReportCallbackEXT(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkDebugReportCallbackCreateInfoEXT*,
+    const VkAllocationCallbacks*,
+    VkDebugReportCallbackEXT*)
+{
+    VkResult on_vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
+    return on_vkCreateDebugReportCallbackEXT_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDebugReportCallbackEXT(
+    void*,
+    VkInstance,
+    VkDebugReportCallbackEXT,
+    const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkDebugReportMessageEXT(
+    void*,
+    VkInstance,
+    VkDebugReportFlagsEXT,
+    VkDebugReportObjectTypeEXT,
+    uint64_t,
+    size_t,
+    int32_t,
+    const char*,
+    const char*)
+{
+}
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+VkResult VkEventHandler::on_vkDebugMarkerSetObjectTagEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkDebugMarkerObjectTagInfoEXT*)
+{
+    VkResult on_vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
+    return on_vkDebugMarkerSetObjectTagEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkDebugMarkerSetObjectNameEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkDebugMarkerObjectNameInfoEXT*)
+{
+    VkResult on_vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
+    return on_vkDebugMarkerSetObjectNameEXT_VkResult_return;
+}
+void VkEventHandler::on_vkCmdDebugMarkerBeginEXT(
+    void*,
+    VkCommandBuffer,
+    const VkDebugMarkerMarkerInfoEXT*)
+{
+}
+void VkEventHandler::on_vkCmdDebugMarkerEndEXT(
+    void*,
+    VkCommandBuffer)
+{
+}
+void VkEventHandler::on_vkCmdDebugMarkerInsertEXT(
+    void*,
+    VkCommandBuffer,
+    const VkDebugMarkerMarkerInfoEXT*)
+{
+}
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+void VkEventHandler::on_vkCmdDrawIndirectCountAMD(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkDeviceSize,
+    VkBuffer,
+    VkDeviceSize,
+    uint32_t,
+    uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexedIndirectCountAMD(
+    void*,
+    VkCommandBuffer,
+    VkBuffer,
+    VkDeviceSize,
+    VkBuffer,
+    VkDeviceSize,
+    uint32_t,
+    uint32_t)
+{
+}
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+VkResult VkEventHandler::on_vkGetShaderInfoAMD(
+    void*,
+    VkResult,
+    VkDevice,
+    VkPipeline,
+    VkShaderStageFlagBits,
+    VkShaderInfoTypeAMD,
+    size_t*,
+    void*)
+{
+    VkResult on_vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
+    return on_vkGetShaderInfoAMD_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+VkResult VkEventHandler::on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkFormat,
+    VkImageType,
+    VkImageTiling,
+    VkImageUsageFlags,
+    VkImageCreateFlags,
+    VkExternalMemoryHandleTypeFlagsNV,
+    VkExternalImageFormatPropertiesNV*)
+{
+    VkResult on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+VkResult VkEventHandler::on_vkGetMemoryWin32HandleNV(
+    void*,
+    VkResult,
+    VkDevice,
+    VkDeviceMemory,
+    VkExternalMemoryHandleTypeFlagsNV,
+    HANDLE*)
+{
+    VkResult on_vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
+    return on_vkGetMemoryWin32HandleNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+VkResult VkEventHandler::on_vkCreateViSurfaceNN(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkViSurfaceCreateInfoNN*,
+    const VkAllocationCallbacks*,
+    VkSurfaceKHR*)
+{
+    VkResult on_vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
+    return on_vkCreateViSurfaceNN_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void VkEventHandler::on_vkCmdBeginConditionalRenderingEXT(
+    void*,
+    VkCommandBuffer,
+    const VkConditionalRenderingBeginInfoEXT*)
+{
+}
+void VkEventHandler::on_vkCmdEndConditionalRenderingEXT(
+    void*,
+    VkCommandBuffer)
+{
+}
+#endif
+#ifdef VK_NVX_device_generated_commands
+void VkEventHandler::on_vkCmdProcessCommandsNVX(
+    void*,
+    VkCommandBuffer,
+    const VkCmdProcessCommandsInfoNVX*)
+{
+}
+void VkEventHandler::on_vkCmdReserveSpaceForCommandsNVX(
+    void*,
+    VkCommandBuffer,
+    const VkCmdReserveSpaceForCommandsInfoNVX*)
+{
+}
+VkResult VkEventHandler::on_vkCreateIndirectCommandsLayoutNVX(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkIndirectCommandsLayoutCreateInfoNVX*,
+    const VkAllocationCallbacks*,
+    VkIndirectCommandsLayoutNVX*)
+{
+    VkResult on_vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
+    return on_vkCreateIndirectCommandsLayoutNVX_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyIndirectCommandsLayoutNVX(
+    void*,
+    VkDevice,
+    VkIndirectCommandsLayoutNVX,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateObjectTableNVX(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkObjectTableCreateInfoNVX*,
+    const VkAllocationCallbacks*,
+    VkObjectTableNVX*)
+{
+    VkResult on_vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
+    return on_vkCreateObjectTableNVX_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyObjectTableNVX(
+    void*,
+    VkDevice,
+    VkObjectTableNVX,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkRegisterObjectsNVX(
+    void*,
+    VkResult,
+    VkDevice,
+    VkObjectTableNVX,
+    uint32_t,
+    const VkObjectTableEntryNVX* const*,
+    const uint32_t*)
+{
+    VkResult on_vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
+    return on_vkRegisterObjectsNVX_VkResult_return;
+}
+VkResult VkEventHandler::on_vkUnregisterObjectsNVX(
+    void*,
+    VkResult,
+    VkDevice,
+    VkObjectTableNVX,
+    uint32_t,
+    const VkObjectEntryTypeNVX*,
+    const uint32_t*)
+{
+    VkResult on_vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
+    return on_vkUnregisterObjectsNVX_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    void*,
+    VkPhysicalDevice,
+    VkDeviceGeneratedCommandsFeaturesNVX*,
+    VkDeviceGeneratedCommandsLimitsNVX*)
+{
+}
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void VkEventHandler::on_vkCmdSetViewportWScalingNV(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    uint32_t,
+    const VkViewportWScalingNV*)
+{
+}
+#endif
+#ifdef VK_EXT_direct_mode_display
+VkResult VkEventHandler::on_vkReleaseDisplayEXT(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkDisplayKHR)
+{
+    VkResult on_vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
+    return on_vkReleaseDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+VkResult VkEventHandler::on_vkAcquireXlibDisplayEXT(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    Display*,
+    VkDisplayKHR)
+{
+    VkResult on_vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
+    return on_vkAcquireXlibDisplayEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetRandROutputDisplayEXT(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    Display*,
+    RROutput,
+    VkDisplayKHR*)
+{
+    VkResult on_vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
+    return on_vkGetRandROutputDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_surface_counter
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+    void*,
+    VkResult,
+    VkPhysicalDevice,
+    VkSurfaceKHR,
+    VkSurfaceCapabilities2EXT*)
+{
+    VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
+    return on_vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_control
+VkResult VkEventHandler::on_vkDisplayPowerControlEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    VkDisplayKHR,
+    const VkDisplayPowerInfoEXT*)
+{
+    VkResult on_vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
+    return on_vkDisplayPowerControlEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkRegisterDeviceEventEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkDeviceEventInfoEXT*,
+    const VkAllocationCallbacks*,
+    VkFence*)
+{
+    VkResult on_vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
+    return on_vkRegisterDeviceEventEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkRegisterDisplayEventEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    VkDisplayKHR,
+    const VkDisplayEventInfoEXT*,
+    const VkAllocationCallbacks*,
+    VkFence*)
+{
+    VkResult on_vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
+    return on_vkRegisterDisplayEventEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetSwapchainCounterEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    VkSwapchainKHR,
+    VkSurfaceCounterFlagBitsEXT,
+    uint64_t*)
+{
+    VkResult on_vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
+    return on_vkGetSwapchainCounterEXT_VkResult_return;
+}
+#endif
+#ifdef VK_GOOGLE_display_timing
+VkResult VkEventHandler::on_vkGetRefreshCycleDurationGOOGLE(
+    void*,
+    VkResult,
+    VkDevice,
+    VkSwapchainKHR,
+    VkRefreshCycleDurationGOOGLE*)
+{
+    VkResult on_vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
+    return on_vkGetRefreshCycleDurationGOOGLE_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPastPresentationTimingGOOGLE(
+    void*,
+    VkResult,
+    VkDevice,
+    VkSwapchainKHR,
+    uint32_t*,
+    VkPastPresentationTimingGOOGLE*)
+{
+    VkResult on_vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
+    return on_vkGetPastPresentationTimingGOOGLE_VkResult_return;
+}
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+void VkEventHandler::on_vkCmdSetDiscardRectangleEXT(
+    void*,
+    VkCommandBuffer,
+    uint32_t,
+    uint32_t,
+    const VkRect2D*)
+{
+}
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void VkEventHandler::on_vkSetHdrMetadataEXT(
+    void*,
+    VkDevice,
+    uint32_t,
+    const VkSwapchainKHR*,
+    const VkHdrMetadataEXT*)
+{
+}
+#endif
+#ifdef VK_MVK_ios_surface
+VkResult VkEventHandler::on_vkCreateIOSSurfaceMVK(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkIOSSurfaceCreateInfoMVK*,
+    const VkAllocationCallbacks*,
+    VkSurfaceKHR*)
+{
+    VkResult on_vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
+    return on_vkCreateIOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_MVK_macos_surface
+VkResult VkEventHandler::on_vkCreateMacOSSurfaceMVK(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkMacOSSurfaceCreateInfoMVK*,
+    const VkAllocationCallbacks*,
+    VkSurfaceKHR*)
+{
+    VkResult on_vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
+    return on_vkCreateMacOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+VkResult VkEventHandler::on_vkSetDebugUtilsObjectNameEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkDebugUtilsObjectNameInfoEXT*)
+{
+    VkResult on_vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
+    return on_vkSetDebugUtilsObjectNameEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkSetDebugUtilsObjectTagEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkDebugUtilsObjectTagInfoEXT*)
+{
+    VkResult on_vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
+    return on_vkSetDebugUtilsObjectTagEXT_VkResult_return;
+}
+void VkEventHandler::on_vkQueueBeginDebugUtilsLabelEXT(
+    void*,
+    VkQueue,
+    const VkDebugUtilsLabelEXT*)
+{
+}
+void VkEventHandler::on_vkQueueEndDebugUtilsLabelEXT(
+    void*,
+    VkQueue)
+{
+}
+void VkEventHandler::on_vkQueueInsertDebugUtilsLabelEXT(
+    void*,
+    VkQueue,
+    const VkDebugUtilsLabelEXT*)
+{
+}
+void VkEventHandler::on_vkCmdBeginDebugUtilsLabelEXT(
+    void*,
+    VkCommandBuffer,
+    const VkDebugUtilsLabelEXT*)
+{
+}
+void VkEventHandler::on_vkCmdEndDebugUtilsLabelEXT(
+    void*,
+    VkCommandBuffer)
+{
+}
+void VkEventHandler::on_vkCmdInsertDebugUtilsLabelEXT(
+    void*,
+    VkCommandBuffer,
+    const VkDebugUtilsLabelEXT*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDebugUtilsMessengerEXT(
+    void*,
+    VkResult,
+    VkInstance,
+    const VkDebugUtilsMessengerCreateInfoEXT*,
+    const VkAllocationCallbacks*,
+    VkDebugUtilsMessengerEXT*)
+{
+    VkResult on_vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
+    return on_vkCreateDebugUtilsMessengerEXT_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDebugUtilsMessengerEXT(
+    void*,
+    VkInstance,
+    VkDebugUtilsMessengerEXT,
+    const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkSubmitDebugUtilsMessageEXT(
+    void*,
+    VkInstance,
+    VkDebugUtilsMessageSeverityFlagBitsEXT,
+    VkDebugUtilsMessageTypeFlagsEXT,
+    const VkDebugUtilsMessengerCallbackDataEXT*)
+{
+}
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+VkResult VkEventHandler::on_vkGetAndroidHardwareBufferPropertiesANDROID(
+    void*,
+    VkResult,
+    VkDevice,
+    const AHardwareBuffer*,
+    VkAndroidHardwareBufferPropertiesANDROID*)
+{
+    VkResult on_vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
+    return on_vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetMemoryAndroidHardwareBufferANDROID(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID*,
+    AHardwareBuffer**)
+{
+    VkResult on_vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
+    return on_vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void VkEventHandler::on_vkCmdSetSampleLocationsEXT(
+    void*,
+    VkCommandBuffer,
+    const VkSampleLocationsInfoEXT*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMultisamplePropertiesEXT(
+    void*,
+    VkPhysicalDevice,
+    VkSampleCountFlagBits,
+    VkMultisamplePropertiesEXT*)
+{
+}
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+VkResult VkEventHandler::on_vkCreateValidationCacheEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    const VkValidationCacheCreateInfoEXT*,
+    const VkAllocationCallbacks*,
+    VkValidationCacheEXT*)
+{
+    VkResult on_vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
+    return on_vkCreateValidationCacheEXT_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyValidationCacheEXT(
+    void*,
+    VkDevice,
+    VkValidationCacheEXT,
+    const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkMergeValidationCachesEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    VkValidationCacheEXT,
+    uint32_t,
+    const VkValidationCacheEXT*)
+{
+    VkResult on_vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
+    return on_vkMergeValidationCachesEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetValidationCacheDataEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    VkValidationCacheEXT,
+    size_t*,
+    void*)
+{
+    VkResult on_vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
+    return on_vkGetValidationCacheDataEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+VkResult VkEventHandler::on_vkGetMemoryHostPointerPropertiesEXT(
+    void*,
+    VkResult,
+    VkDevice,
+    VkExternalMemoryHandleTypeFlagBits,
+    const void*,
+    VkMemoryHostPointerPropertiesEXT*)
+{
+    VkResult on_vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
+    return on_vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_buffer_marker
+void VkEventHandler::on_vkCmdWriteBufferMarkerAMD(
+    void*,
+    VkCommandBuffer,
+    VkPipelineStageFlagBits,
+    VkBuffer,
+    VkDeviceSize,
+    uint32_t)
+{
+}
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void VkEventHandler::on_vkCmdSetCheckpointNV(
+    void*,
+    VkCommandBuffer,
+    const void*)
+{
+}
+void VkEventHandler::on_vkGetQueueCheckpointDataNV(
+    void*,
+    VkQueue,
+    uint32_t*,
+    VkCheckpointDataNV*)
+{
+}
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEventHandler.h b/system/vulkan_enc/VkEventHandler.h
new file mode 100644
index 0000000..fcc4192
--- /dev/null
+++ b/system/vulkan_enc/VkEventHandler.h
@@ -0,0 +1,2218 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module VkEventHandler
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+
+class VkEncoder;
+class VkEventHandler {
+public:
+    VkEventHandler();
+    virtual ~VkEventHandler();
+#ifdef VK_VERSION_1_0
+    virtual VkResult on_vkCreateInstance(
+    void* context,
+        VkResult input_result,
+        const VkInstanceCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkInstance* pInstance);
+    virtual void on_vkDestroyInstance(
+    void* context,
+        VkInstance instance,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkEnumeratePhysicalDevices(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        uint32_t* pPhysicalDeviceCount,
+        VkPhysicalDevice* pPhysicalDevices);
+    virtual void on_vkGetPhysicalDeviceFeatures(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceFeatures* pFeatures);
+    virtual void on_vkGetPhysicalDeviceFormatProperties(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkFormatProperties* pFormatProperties);
+    virtual VkResult on_vkGetPhysicalDeviceImageFormatProperties(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkImageType type,
+        VkImageTiling tiling,
+        VkImageUsageFlags usage,
+        VkImageCreateFlags flags,
+        VkImageFormatProperties* pImageFormatProperties);
+    virtual void on_vkGetPhysicalDeviceProperties(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceProperties* pProperties);
+    virtual void on_vkGetPhysicalDeviceQueueFamilyProperties(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        uint32_t* pQueueFamilyPropertyCount,
+        VkQueueFamilyProperties* pQueueFamilyProperties);
+    virtual void on_vkGetPhysicalDeviceMemoryProperties(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+    virtual PFN_vkVoidFunction on_vkGetInstanceProcAddr(
+    void* context,
+        PFN_vkVoidFunction input_result,
+        VkInstance instance,
+        const char* pName);
+    virtual PFN_vkVoidFunction on_vkGetDeviceProcAddr(
+    void* context,
+        PFN_vkVoidFunction input_result,
+        VkDevice device,
+        const char* pName);
+    virtual VkResult on_vkCreateDevice(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        const VkDeviceCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDevice* pDevice);
+    virtual void on_vkDestroyDevice(
+    void* context,
+        VkDevice device,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkEnumerateInstanceExtensionProperties(
+    void* context,
+        VkResult input_result,
+        const char* pLayerName,
+        uint32_t* pPropertyCount,
+        VkExtensionProperties* pProperties);
+    virtual VkResult on_vkEnumerateDeviceExtensionProperties(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        const char* pLayerName,
+        uint32_t* pPropertyCount,
+        VkExtensionProperties* pProperties);
+    virtual VkResult on_vkEnumerateInstanceLayerProperties(
+    void* context,
+        VkResult input_result,
+        uint32_t* pPropertyCount,
+        VkLayerProperties* pProperties);
+    virtual VkResult on_vkEnumerateDeviceLayerProperties(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t* pPropertyCount,
+        VkLayerProperties* pProperties);
+    virtual void on_vkGetDeviceQueue(
+    void* context,
+        VkDevice device,
+        uint32_t queueFamilyIndex,
+        uint32_t queueIndex,
+        VkQueue* pQueue);
+    virtual VkResult on_vkQueueSubmit(
+    void* context,
+        VkResult input_result,
+        VkQueue queue,
+        uint32_t submitCount,
+        const VkSubmitInfo* pSubmits,
+        VkFence fence);
+    virtual VkResult on_vkQueueWaitIdle(
+    void* context,
+        VkResult input_result,
+        VkQueue queue);
+    virtual VkResult on_vkDeviceWaitIdle(
+    void* context,
+        VkResult input_result,
+        VkDevice device);
+    virtual VkResult on_vkAllocateMemory(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkMemoryAllocateInfo* pAllocateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDeviceMemory* pMemory);
+    virtual void on_vkFreeMemory(
+    void* context,
+        VkDevice device,
+        VkDeviceMemory memory,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkMapMemory(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkDeviceMemory memory,
+        VkDeviceSize offset,
+        VkDeviceSize size,
+        VkMemoryMapFlags flags,
+        void** ppData);
+    virtual void on_vkUnmapMemory(
+    void* context,
+        VkDevice device,
+        VkDeviceMemory memory);
+    virtual VkResult on_vkFlushMappedMemoryRanges(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t memoryRangeCount,
+        const VkMappedMemoryRange* pMemoryRanges);
+    virtual VkResult on_vkInvalidateMappedMemoryRanges(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t memoryRangeCount,
+        const VkMappedMemoryRange* pMemoryRanges);
+    virtual void on_vkGetDeviceMemoryCommitment(
+    void* context,
+        VkDevice device,
+        VkDeviceMemory memory,
+        VkDeviceSize* pCommittedMemoryInBytes);
+    virtual VkResult on_vkBindBufferMemory(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkBuffer buffer,
+        VkDeviceMemory memory,
+        VkDeviceSize memoryOffset);
+    virtual VkResult on_vkBindImageMemory(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkImage image,
+        VkDeviceMemory memory,
+        VkDeviceSize memoryOffset);
+    virtual void on_vkGetBufferMemoryRequirements(
+    void* context,
+        VkDevice device,
+        VkBuffer buffer,
+        VkMemoryRequirements* pMemoryRequirements);
+    virtual void on_vkGetImageMemoryRequirements(
+    void* context,
+        VkDevice device,
+        VkImage image,
+        VkMemoryRequirements* pMemoryRequirements);
+    virtual void on_vkGetImageSparseMemoryRequirements(
+    void* context,
+        VkDevice device,
+        VkImage image,
+        uint32_t* pSparseMemoryRequirementCount,
+        VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+    virtual void on_vkGetPhysicalDeviceSparseImageFormatProperties(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkImageType type,
+        VkSampleCountFlagBits samples,
+        VkImageUsageFlags usage,
+        VkImageTiling tiling,
+        uint32_t* pPropertyCount,
+        VkSparseImageFormatProperties* pProperties);
+    virtual VkResult on_vkQueueBindSparse(
+    void* context,
+        VkResult input_result,
+        VkQueue queue,
+        uint32_t bindInfoCount,
+        const VkBindSparseInfo* pBindInfo,
+        VkFence fence);
+    virtual VkResult on_vkCreateFence(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkFenceCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkFence* pFence);
+    virtual void on_vkDestroyFence(
+    void* context,
+        VkDevice device,
+        VkFence fence,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkResetFences(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t fenceCount,
+        const VkFence* pFences);
+    virtual VkResult on_vkGetFenceStatus(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkFence fence);
+    virtual VkResult on_vkWaitForFences(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t fenceCount,
+        const VkFence* pFences,
+        VkBool32 waitAll,
+        uint64_t timeout);
+    virtual VkResult on_vkCreateSemaphore(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkSemaphoreCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSemaphore* pSemaphore);
+    virtual void on_vkDestroySemaphore(
+    void* context,
+        VkDevice device,
+        VkSemaphore semaphore,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreateEvent(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkEventCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkEvent* pEvent);
+    virtual void on_vkDestroyEvent(
+    void* context,
+        VkDevice device,
+        VkEvent event,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkGetEventStatus(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkEvent event);
+    virtual VkResult on_vkSetEvent(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkEvent event);
+    virtual VkResult on_vkResetEvent(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkEvent event);
+    virtual VkResult on_vkCreateQueryPool(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkQueryPoolCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkQueryPool* pQueryPool);
+    virtual void on_vkDestroyQueryPool(
+    void* context,
+        VkDevice device,
+        VkQueryPool queryPool,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkGetQueryPoolResults(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkQueryPool queryPool,
+        uint32_t firstQuery,
+        uint32_t queryCount,
+        size_t dataSize,
+        void* pData,
+        VkDeviceSize stride,
+        VkQueryResultFlags flags);
+    virtual VkResult on_vkCreateBuffer(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkBufferCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkBuffer* pBuffer);
+    virtual void on_vkDestroyBuffer(
+    void* context,
+        VkDevice device,
+        VkBuffer buffer,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreateBufferView(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkBufferViewCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkBufferView* pView);
+    virtual void on_vkDestroyBufferView(
+    void* context,
+        VkDevice device,
+        VkBufferView bufferView,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreateImage(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkImageCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkImage* pImage);
+    virtual void on_vkDestroyImage(
+    void* context,
+        VkDevice device,
+        VkImage image,
+        const VkAllocationCallbacks* pAllocator);
+    virtual void on_vkGetImageSubresourceLayout(
+    void* context,
+        VkDevice device,
+        VkImage image,
+        const VkImageSubresource* pSubresource,
+        VkSubresourceLayout* pLayout);
+    virtual VkResult on_vkCreateImageView(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkImageViewCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkImageView* pView);
+    virtual void on_vkDestroyImageView(
+    void* context,
+        VkDevice device,
+        VkImageView imageView,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreateShaderModule(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkShaderModuleCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkShaderModule* pShaderModule);
+    virtual void on_vkDestroyShaderModule(
+    void* context,
+        VkDevice device,
+        VkShaderModule shaderModule,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreatePipelineCache(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkPipelineCacheCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkPipelineCache* pPipelineCache);
+    virtual void on_vkDestroyPipelineCache(
+    void* context,
+        VkDevice device,
+        VkPipelineCache pipelineCache,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkGetPipelineCacheData(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkPipelineCache pipelineCache,
+        size_t* pDataSize,
+        void* pData);
+    virtual VkResult on_vkMergePipelineCaches(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkPipelineCache dstCache,
+        uint32_t srcCacheCount,
+        const VkPipelineCache* pSrcCaches);
+    virtual VkResult on_vkCreateGraphicsPipelines(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkPipelineCache pipelineCache,
+        uint32_t createInfoCount,
+        const VkGraphicsPipelineCreateInfo* pCreateInfos,
+        const VkAllocationCallbacks* pAllocator,
+        VkPipeline* pPipelines);
+    virtual VkResult on_vkCreateComputePipelines(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkPipelineCache pipelineCache,
+        uint32_t createInfoCount,
+        const VkComputePipelineCreateInfo* pCreateInfos,
+        const VkAllocationCallbacks* pAllocator,
+        VkPipeline* pPipelines);
+    virtual void on_vkDestroyPipeline(
+    void* context,
+        VkDevice device,
+        VkPipeline pipeline,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreatePipelineLayout(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkPipelineLayoutCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkPipelineLayout* pPipelineLayout);
+    virtual void on_vkDestroyPipelineLayout(
+    void* context,
+        VkDevice device,
+        VkPipelineLayout pipelineLayout,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreateSampler(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkSamplerCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSampler* pSampler);
+    virtual void on_vkDestroySampler(
+    void* context,
+        VkDevice device,
+        VkSampler sampler,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreateDescriptorSetLayout(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDescriptorSetLayout* pSetLayout);
+    virtual void on_vkDestroyDescriptorSetLayout(
+    void* context,
+        VkDevice device,
+        VkDescriptorSetLayout descriptorSetLayout,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreateDescriptorPool(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkDescriptorPoolCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDescriptorPool* pDescriptorPool);
+    virtual void on_vkDestroyDescriptorPool(
+    void* context,
+        VkDevice device,
+        VkDescriptorPool descriptorPool,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkResetDescriptorPool(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkDescriptorPool descriptorPool,
+        VkDescriptorPoolResetFlags flags);
+    virtual VkResult on_vkAllocateDescriptorSets(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkDescriptorSetAllocateInfo* pAllocateInfo,
+        VkDescriptorSet* pDescriptorSets);
+    virtual VkResult on_vkFreeDescriptorSets(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkDescriptorPool descriptorPool,
+        uint32_t descriptorSetCount,
+        const VkDescriptorSet* pDescriptorSets);
+    virtual void on_vkUpdateDescriptorSets(
+    void* context,
+        VkDevice device,
+        uint32_t descriptorWriteCount,
+        const VkWriteDescriptorSet* pDescriptorWrites,
+        uint32_t descriptorCopyCount,
+        const VkCopyDescriptorSet* pDescriptorCopies);
+    virtual VkResult on_vkCreateFramebuffer(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkFramebufferCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkFramebuffer* pFramebuffer);
+    virtual void on_vkDestroyFramebuffer(
+    void* context,
+        VkDevice device,
+        VkFramebuffer framebuffer,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreateRenderPass(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkRenderPassCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkRenderPass* pRenderPass);
+    virtual void on_vkDestroyRenderPass(
+    void* context,
+        VkDevice device,
+        VkRenderPass renderPass,
+        const VkAllocationCallbacks* pAllocator);
+    virtual void on_vkGetRenderAreaGranularity(
+    void* context,
+        VkDevice device,
+        VkRenderPass renderPass,
+        VkExtent2D* pGranularity);
+    virtual VkResult on_vkCreateCommandPool(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkCommandPoolCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkCommandPool* pCommandPool);
+    virtual void on_vkDestroyCommandPool(
+    void* context,
+        VkDevice device,
+        VkCommandPool commandPool,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkResetCommandPool(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkCommandPool commandPool,
+        VkCommandPoolResetFlags flags);
+    virtual VkResult on_vkAllocateCommandBuffers(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkCommandBufferAllocateInfo* pAllocateInfo,
+        VkCommandBuffer* pCommandBuffers);
+    virtual void on_vkFreeCommandBuffers(
+    void* context,
+        VkDevice device,
+        VkCommandPool commandPool,
+        uint32_t commandBufferCount,
+        const VkCommandBuffer* pCommandBuffers);
+    virtual VkResult on_vkBeginCommandBuffer(
+    void* context,
+        VkResult input_result,
+        VkCommandBuffer commandBuffer,
+        const VkCommandBufferBeginInfo* pBeginInfo);
+    virtual VkResult on_vkEndCommandBuffer(
+    void* context,
+        VkResult input_result,
+        VkCommandBuffer commandBuffer);
+    virtual VkResult on_vkResetCommandBuffer(
+    void* context,
+        VkResult input_result,
+        VkCommandBuffer commandBuffer,
+        VkCommandBufferResetFlags flags);
+    virtual void on_vkCmdBindPipeline(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkPipelineBindPoint pipelineBindPoint,
+        VkPipeline pipeline);
+    virtual void on_vkCmdSetViewport(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t firstViewport,
+        uint32_t viewportCount,
+        const VkViewport* pViewports);
+    virtual void on_vkCmdSetScissor(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t firstScissor,
+        uint32_t scissorCount,
+        const VkRect2D* pScissors);
+    virtual void on_vkCmdSetLineWidth(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        float lineWidth);
+    virtual void on_vkCmdSetDepthBias(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        float depthBiasConstantFactor,
+        float depthBiasClamp,
+        float depthBiasSlopeFactor);
+    virtual void on_vkCmdSetBlendConstants(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const float blendConstants);
+    virtual void on_vkCmdSetDepthBounds(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        float minDepthBounds,
+        float maxDepthBounds);
+    virtual void on_vkCmdSetStencilCompareMask(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkStencilFaceFlags faceMask,
+        uint32_t compareMask);
+    virtual void on_vkCmdSetStencilWriteMask(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkStencilFaceFlags faceMask,
+        uint32_t writeMask);
+    virtual void on_vkCmdSetStencilReference(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkStencilFaceFlags faceMask,
+        uint32_t reference);
+    virtual void on_vkCmdBindDescriptorSets(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkPipelineBindPoint pipelineBindPoint,
+        VkPipelineLayout layout,
+        uint32_t firstSet,
+        uint32_t descriptorSetCount,
+        const VkDescriptorSet* pDescriptorSets,
+        uint32_t dynamicOffsetCount,
+        const uint32_t* pDynamicOffsets);
+    virtual void on_vkCmdBindIndexBuffer(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        VkIndexType indexType);
+    virtual void on_vkCmdBindVertexBuffers(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t firstBinding,
+        uint32_t bindingCount,
+        const VkBuffer* pBuffers,
+        const VkDeviceSize* pOffsets);
+    virtual void on_vkCmdDraw(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t vertexCount,
+        uint32_t instanceCount,
+        uint32_t firstVertex,
+        uint32_t firstInstance);
+    virtual void on_vkCmdDrawIndexed(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t indexCount,
+        uint32_t instanceCount,
+        uint32_t firstIndex,
+        int32_t vertexOffset,
+        uint32_t firstInstance);
+    virtual void on_vkCmdDrawIndirect(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        uint32_t drawCount,
+        uint32_t stride);
+    virtual void on_vkCmdDrawIndexedIndirect(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        uint32_t drawCount,
+        uint32_t stride);
+    virtual void on_vkCmdDispatch(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t groupCountX,
+        uint32_t groupCountY,
+        uint32_t groupCountZ);
+    virtual void on_vkCmdDispatchIndirect(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset);
+    virtual void on_vkCmdCopyBuffer(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer srcBuffer,
+        VkBuffer dstBuffer,
+        uint32_t regionCount,
+        const VkBufferCopy* pRegions);
+    virtual void on_vkCmdCopyImage(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkImage srcImage,
+        VkImageLayout srcImageLayout,
+        VkImage dstImage,
+        VkImageLayout dstImageLayout,
+        uint32_t regionCount,
+        const VkImageCopy* pRegions);
+    virtual void on_vkCmdBlitImage(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkImage srcImage,
+        VkImageLayout srcImageLayout,
+        VkImage dstImage,
+        VkImageLayout dstImageLayout,
+        uint32_t regionCount,
+        const VkImageBlit* pRegions,
+        VkFilter filter);
+    virtual void on_vkCmdCopyBufferToImage(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer srcBuffer,
+        VkImage dstImage,
+        VkImageLayout dstImageLayout,
+        uint32_t regionCount,
+        const VkBufferImageCopy* pRegions);
+    virtual void on_vkCmdCopyImageToBuffer(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkImage srcImage,
+        VkImageLayout srcImageLayout,
+        VkBuffer dstBuffer,
+        uint32_t regionCount,
+        const VkBufferImageCopy* pRegions);
+    virtual void on_vkCmdUpdateBuffer(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer dstBuffer,
+        VkDeviceSize dstOffset,
+        VkDeviceSize dataSize,
+        const void* pData);
+    virtual void on_vkCmdFillBuffer(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer dstBuffer,
+        VkDeviceSize dstOffset,
+        VkDeviceSize size,
+        uint32_t data);
+    virtual void on_vkCmdClearColorImage(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkImage image,
+        VkImageLayout imageLayout,
+        const VkClearColorValue* pColor,
+        uint32_t rangeCount,
+        const VkImageSubresourceRange* pRanges);
+    virtual void on_vkCmdClearDepthStencilImage(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkImage image,
+        VkImageLayout imageLayout,
+        const VkClearDepthStencilValue* pDepthStencil,
+        uint32_t rangeCount,
+        const VkImageSubresourceRange* pRanges);
+    virtual void on_vkCmdClearAttachments(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t attachmentCount,
+        const VkClearAttachment* pAttachments,
+        uint32_t rectCount,
+        const VkClearRect* pRects);
+    virtual void on_vkCmdResolveImage(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkImage srcImage,
+        VkImageLayout srcImageLayout,
+        VkImage dstImage,
+        VkImageLayout dstImageLayout,
+        uint32_t regionCount,
+        const VkImageResolve* pRegions);
+    virtual void on_vkCmdSetEvent(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkEvent event,
+        VkPipelineStageFlags stageMask);
+    virtual void on_vkCmdResetEvent(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkEvent event,
+        VkPipelineStageFlags stageMask);
+    virtual void on_vkCmdWaitEvents(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t eventCount,
+        const VkEvent* pEvents,
+        VkPipelineStageFlags srcStageMask,
+        VkPipelineStageFlags dstStageMask,
+        uint32_t memoryBarrierCount,
+        const VkMemoryBarrier* pMemoryBarriers,
+        uint32_t bufferMemoryBarrierCount,
+        const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+        uint32_t imageMemoryBarrierCount,
+        const VkImageMemoryBarrier* pImageMemoryBarriers);
+    virtual void on_vkCmdPipelineBarrier(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkPipelineStageFlags srcStageMask,
+        VkPipelineStageFlags dstStageMask,
+        VkDependencyFlags dependencyFlags,
+        uint32_t memoryBarrierCount,
+        const VkMemoryBarrier* pMemoryBarriers,
+        uint32_t bufferMemoryBarrierCount,
+        const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+        uint32_t imageMemoryBarrierCount,
+        const VkImageMemoryBarrier* pImageMemoryBarriers);
+    virtual void on_vkCmdBeginQuery(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkQueryPool queryPool,
+        uint32_t query,
+        VkQueryControlFlags flags);
+    virtual void on_vkCmdEndQuery(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkQueryPool queryPool,
+        uint32_t query);
+    virtual void on_vkCmdResetQueryPool(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkQueryPool queryPool,
+        uint32_t firstQuery,
+        uint32_t queryCount);
+    virtual void on_vkCmdWriteTimestamp(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkPipelineStageFlagBits pipelineStage,
+        VkQueryPool queryPool,
+        uint32_t query);
+    virtual void on_vkCmdCopyQueryPoolResults(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkQueryPool queryPool,
+        uint32_t firstQuery,
+        uint32_t queryCount,
+        VkBuffer dstBuffer,
+        VkDeviceSize dstOffset,
+        VkDeviceSize stride,
+        VkQueryResultFlags flags);
+    virtual void on_vkCmdPushConstants(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkPipelineLayout layout,
+        VkShaderStageFlags stageFlags,
+        uint32_t offset,
+        uint32_t size,
+        const void* pValues);
+    virtual void on_vkCmdBeginRenderPass(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkRenderPassBeginInfo* pRenderPassBegin,
+        VkSubpassContents contents);
+    virtual void on_vkCmdNextSubpass(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkSubpassContents contents);
+    virtual void on_vkCmdEndRenderPass(
+    void* context,
+        VkCommandBuffer commandBuffer);
+    virtual void on_vkCmdExecuteCommands(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t commandBufferCount,
+        const VkCommandBuffer* pCommandBuffers);
+#endif
+#ifdef VK_VERSION_1_1
+    virtual VkResult on_vkEnumerateInstanceVersion(
+    void* context,
+        VkResult input_result,
+        uint32_t* pApiVersion);
+    virtual VkResult on_vkBindBufferMemory2(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t bindInfoCount,
+        const VkBindBufferMemoryInfo* pBindInfos);
+    virtual VkResult on_vkBindImageMemory2(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t bindInfoCount,
+        const VkBindImageMemoryInfo* pBindInfos);
+    virtual void on_vkGetDeviceGroupPeerMemoryFeatures(
+    void* context,
+        VkDevice device,
+        uint32_t heapIndex,
+        uint32_t localDeviceIndex,
+        uint32_t remoteDeviceIndex,
+        VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+    virtual void on_vkCmdSetDeviceMask(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t deviceMask);
+    virtual void on_vkCmdDispatchBase(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t baseGroupX,
+        uint32_t baseGroupY,
+        uint32_t baseGroupZ,
+        uint32_t groupCountX,
+        uint32_t groupCountY,
+        uint32_t groupCountZ);
+    virtual VkResult on_vkEnumeratePhysicalDeviceGroups(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        uint32_t* pPhysicalDeviceGroupCount,
+        VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+    virtual void on_vkGetImageMemoryRequirements2(
+    void* context,
+        VkDevice device,
+        const VkImageMemoryRequirementsInfo2* pInfo,
+        VkMemoryRequirements2* pMemoryRequirements);
+    virtual void on_vkGetBufferMemoryRequirements2(
+    void* context,
+        VkDevice device,
+        const VkBufferMemoryRequirementsInfo2* pInfo,
+        VkMemoryRequirements2* pMemoryRequirements);
+    virtual void on_vkGetImageSparseMemoryRequirements2(
+    void* context,
+        VkDevice device,
+        const VkImageSparseMemoryRequirementsInfo2* pInfo,
+        uint32_t* pSparseMemoryRequirementCount,
+        VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+    virtual void on_vkGetPhysicalDeviceFeatures2(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceFeatures2* pFeatures);
+    virtual void on_vkGetPhysicalDeviceProperties2(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceProperties2* pProperties);
+    virtual void on_vkGetPhysicalDeviceFormatProperties2(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkFormatProperties2* pFormatProperties);
+    virtual VkResult on_vkGetPhysicalDeviceImageFormatProperties2(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+        VkImageFormatProperties2* pImageFormatProperties);
+    virtual void on_vkGetPhysicalDeviceQueueFamilyProperties2(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        uint32_t* pQueueFamilyPropertyCount,
+        VkQueueFamilyProperties2* pQueueFamilyProperties);
+    virtual void on_vkGetPhysicalDeviceMemoryProperties2(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+    virtual void on_vkGetPhysicalDeviceSparseImageFormatProperties2(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+        uint32_t* pPropertyCount,
+        VkSparseImageFormatProperties2* pProperties);
+    virtual void on_vkTrimCommandPool(
+    void* context,
+        VkDevice device,
+        VkCommandPool commandPool,
+        VkCommandPoolTrimFlags flags);
+    virtual void on_vkGetDeviceQueue2(
+    void* context,
+        VkDevice device,
+        const VkDeviceQueueInfo2* pQueueInfo,
+        VkQueue* pQueue);
+    virtual VkResult on_vkCreateSamplerYcbcrConversion(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSamplerYcbcrConversion* pYcbcrConversion);
+    virtual void on_vkDestroySamplerYcbcrConversion(
+    void* context,
+        VkDevice device,
+        VkSamplerYcbcrConversion ycbcrConversion,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreateDescriptorUpdateTemplate(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+    virtual void on_vkDestroyDescriptorUpdateTemplate(
+    void* context,
+        VkDevice device,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+        const VkAllocationCallbacks* pAllocator);
+    virtual void on_vkUpdateDescriptorSetWithTemplate(
+    void* context,
+        VkDevice device,
+        VkDescriptorSet descriptorSet,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+        const void* pData);
+    virtual void on_vkGetPhysicalDeviceExternalBufferProperties(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+        VkExternalBufferProperties* pExternalBufferProperties);
+    virtual void on_vkGetPhysicalDeviceExternalFenceProperties(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+        VkExternalFenceProperties* pExternalFenceProperties);
+    virtual void on_vkGetPhysicalDeviceExternalSemaphoreProperties(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+        VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+    virtual void on_vkGetDescriptorSetLayoutSupport(
+    void* context,
+        VkDevice device,
+        const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+        VkDescriptorSetLayoutSupport* pSupport);
+#endif
+#ifdef VK_KHR_surface
+    virtual void on_vkDestroySurfaceKHR(
+    void* context,
+        VkInstance instance,
+        VkSurfaceKHR surface,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkGetPhysicalDeviceSurfaceSupportKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex,
+        VkSurfaceKHR surface,
+        VkBool32* pSupported);
+    virtual VkResult on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkSurfaceKHR surface,
+        VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+    virtual VkResult on_vkGetPhysicalDeviceSurfaceFormatsKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkSurfaceKHR surface,
+        uint32_t* pSurfaceFormatCount,
+        VkSurfaceFormatKHR* pSurfaceFormats);
+    virtual VkResult on_vkGetPhysicalDeviceSurfacePresentModesKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkSurfaceKHR surface,
+        uint32_t* pPresentModeCount,
+        VkPresentModeKHR* pPresentModes);
+#endif
+#ifdef VK_KHR_swapchain
+    virtual VkResult on_vkCreateSwapchainKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkSwapchainCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSwapchainKHR* pSwapchain);
+    virtual void on_vkDestroySwapchainKHR(
+    void* context,
+        VkDevice device,
+        VkSwapchainKHR swapchain,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkGetSwapchainImagesKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkSwapchainKHR swapchain,
+        uint32_t* pSwapchainImageCount,
+        VkImage* pSwapchainImages);
+    virtual VkResult on_vkAcquireNextImageKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkSwapchainKHR swapchain,
+        uint64_t timeout,
+        VkSemaphore semaphore,
+        VkFence fence,
+        uint32_t* pImageIndex);
+    virtual VkResult on_vkQueuePresentKHR(
+    void* context,
+        VkResult input_result,
+        VkQueue queue,
+        const VkPresentInfoKHR* pPresentInfo);
+    virtual VkResult on_vkGetDeviceGroupPresentCapabilitiesKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
+    virtual VkResult on_vkGetDeviceGroupSurfacePresentModesKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkSurfaceKHR surface,
+        VkDeviceGroupPresentModeFlagsKHR* pModes);
+    virtual VkResult on_vkGetPhysicalDevicePresentRectanglesKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkSurfaceKHR surface,
+        uint32_t* pRectCount,
+        VkRect2D* pRects);
+    virtual VkResult on_vkAcquireNextImage2KHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkAcquireNextImageInfoKHR* pAcquireInfo,
+        uint32_t* pImageIndex);
+#endif
+#ifdef VK_KHR_display
+    virtual VkResult on_vkGetPhysicalDeviceDisplayPropertiesKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t* pPropertyCount,
+        VkDisplayPropertiesKHR* pProperties);
+    virtual VkResult on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t* pPropertyCount,
+        VkDisplayPlanePropertiesKHR* pProperties);
+    virtual VkResult on_vkGetDisplayPlaneSupportedDisplaysKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t planeIndex,
+        uint32_t* pDisplayCount,
+        VkDisplayKHR* pDisplays);
+    virtual VkResult on_vkGetDisplayModePropertiesKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkDisplayKHR display,
+        uint32_t* pPropertyCount,
+        VkDisplayModePropertiesKHR* pProperties);
+    virtual VkResult on_vkCreateDisplayModeKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkDisplayKHR display,
+        const VkDisplayModeCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDisplayModeKHR* pMode);
+    virtual VkResult on_vkGetDisplayPlaneCapabilitiesKHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkDisplayModeKHR mode,
+        uint32_t planeIndex,
+        VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+    virtual VkResult on_vkCreateDisplayPlaneSurfaceKHR(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_KHR_display_swapchain
+    virtual VkResult on_vkCreateSharedSwapchainsKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t swapchainCount,
+        const VkSwapchainCreateInfoKHR* pCreateInfos,
+        const VkAllocationCallbacks* pAllocator,
+        VkSwapchainKHR* pSwapchains);
+#endif
+#ifdef VK_KHR_xlib_surface
+    virtual VkResult on_vkCreateXlibSurfaceKHR(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+    virtual VkBool32 on_vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    void* context,
+        VkBool32 input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex,
+        Display* dpy,
+        VisualID visualID);
+#endif
+#ifdef VK_KHR_xcb_surface
+    virtual VkResult on_vkCreateXcbSurfaceKHR(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+    virtual VkBool32 on_vkGetPhysicalDeviceXcbPresentationSupportKHR(
+    void* context,
+        VkBool32 input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex,
+        xcb_connection_t* connection,
+        xcb_visualid_t visual_id);
+#endif
+#ifdef VK_KHR_wayland_surface
+    virtual VkResult on_vkCreateWaylandSurfaceKHR(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+    virtual VkBool32 on_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+    void* context,
+        VkBool32 input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex,
+        wl_display* display);
+#endif
+#ifdef VK_KHR_mir_surface
+    virtual VkResult on_vkCreateMirSurfaceKHR(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+    virtual VkBool32 on_vkGetPhysicalDeviceMirPresentationSupportKHR(
+    void* context,
+        VkBool32 input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex,
+        MirConnection* connection);
+#endif
+#ifdef VK_KHR_android_surface
+    virtual VkResult on_vkCreateAndroidSurfaceKHR(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_KHR_win32_surface
+    virtual VkResult on_vkCreateWin32SurfaceKHR(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+    virtual VkBool32 on_vkGetPhysicalDeviceWin32PresentationSupportKHR(
+    void* context,
+        VkBool32 input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t queueFamilyIndex);
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+    virtual void on_vkGetPhysicalDeviceFeatures2KHR(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceFeatures2* pFeatures);
+    virtual void on_vkGetPhysicalDeviceProperties2KHR(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceProperties2* pProperties);
+    virtual void on_vkGetPhysicalDeviceFormatProperties2KHR(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkFormatProperties2* pFormatProperties);
+    virtual VkResult on_vkGetPhysicalDeviceImageFormatProperties2KHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+        VkImageFormatProperties2* pImageFormatProperties);
+    virtual void on_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        uint32_t* pQueueFamilyPropertyCount,
+        VkQueueFamilyProperties2* pQueueFamilyProperties);
+    virtual void on_vkGetPhysicalDeviceMemoryProperties2KHR(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+    virtual void on_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+        uint32_t* pPropertyCount,
+        VkSparseImageFormatProperties2* pProperties);
+#endif
+#ifdef VK_KHR_device_group
+    virtual void on_vkGetDeviceGroupPeerMemoryFeaturesKHR(
+    void* context,
+        VkDevice device,
+        uint32_t heapIndex,
+        uint32_t localDeviceIndex,
+        uint32_t remoteDeviceIndex,
+        VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+    virtual void on_vkCmdSetDeviceMaskKHR(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t deviceMask);
+    virtual void on_vkCmdDispatchBaseKHR(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t baseGroupX,
+        uint32_t baseGroupY,
+        uint32_t baseGroupZ,
+        uint32_t groupCountX,
+        uint32_t groupCountY,
+        uint32_t groupCountZ);
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+    virtual void on_vkTrimCommandPoolKHR(
+    void* context,
+        VkDevice device,
+        VkCommandPool commandPool,
+        VkCommandPoolTrimFlags flags);
+#endif
+#ifdef VK_KHR_device_group_creation
+    virtual VkResult on_vkEnumeratePhysicalDeviceGroupsKHR(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        uint32_t* pPhysicalDeviceGroupCount,
+        VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+    virtual void on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+        VkExternalBufferProperties* pExternalBufferProperties);
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+    virtual VkResult on_vkGetMemoryWin32HandleKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+        HANDLE* pHandle);
+    virtual VkResult on_vkGetMemoryWin32HandlePropertiesKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkExternalMemoryHandleTypeFlagBits handleType,
+        HANDLE handle,
+        VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+#endif
+#ifdef VK_KHR_external_memory_fd
+    virtual VkResult on_vkGetMemoryFdKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkMemoryGetFdInfoKHR* pGetFdInfo,
+        int* pFd);
+    virtual VkResult on_vkGetMemoryFdPropertiesKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkExternalMemoryHandleTypeFlagBits handleType,
+        int fd,
+        VkMemoryFdPropertiesKHR* pMemoryFdProperties);
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+    virtual void on_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+        VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+    virtual VkResult on_vkImportSemaphoreWin32HandleKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+    virtual VkResult on_vkGetSemaphoreWin32HandleKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+        HANDLE* pHandle);
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+    virtual VkResult on_vkImportSemaphoreFdKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
+    virtual VkResult on_vkGetSemaphoreFdKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+        int* pFd);
+#endif
+#ifdef VK_KHR_push_descriptor
+    virtual void on_vkCmdPushDescriptorSetKHR(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkPipelineBindPoint pipelineBindPoint,
+        VkPipelineLayout layout,
+        uint32_t set,
+        uint32_t descriptorWriteCount,
+        const VkWriteDescriptorSet* pDescriptorWrites);
+    virtual void on_vkCmdPushDescriptorSetWithTemplateKHR(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+        VkPipelineLayout layout,
+        uint32_t set,
+        const void* pData);
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+    virtual VkResult on_vkCreateDescriptorUpdateTemplateKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+    virtual void on_vkDestroyDescriptorUpdateTemplateKHR(
+    void* context,
+        VkDevice device,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+        const VkAllocationCallbacks* pAllocator);
+    virtual void on_vkUpdateDescriptorSetWithTemplateKHR(
+    void* context,
+        VkDevice device,
+        VkDescriptorSet descriptorSet,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+        const void* pData);
+#endif
+#ifdef VK_KHR_create_renderpass2
+    virtual VkResult on_vkCreateRenderPass2KHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkRenderPassCreateInfo2KHR* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkRenderPass* pRenderPass);
+    virtual void on_vkCmdBeginRenderPass2KHR(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkRenderPassBeginInfo* pRenderPassBegin,
+        const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
+    virtual void on_vkCmdNextSubpass2KHR(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+        const VkSubpassEndInfoKHR* pSubpassEndInfo);
+    virtual void on_vkCmdEndRenderPass2KHR(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkSubpassEndInfoKHR* pSubpassEndInfo);
+#endif
+#ifdef VK_KHR_shared_presentable_image
+    virtual VkResult on_vkGetSwapchainStatusKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkSwapchainKHR swapchain);
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+    virtual void on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+        VkExternalFenceProperties* pExternalFenceProperties);
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+    virtual VkResult on_vkImportFenceWin32HandleKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+    virtual VkResult on_vkGetFenceWin32HandleKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+        HANDLE* pHandle);
+#endif
+#ifdef VK_KHR_external_fence_fd
+    virtual VkResult on_vkImportFenceFdKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
+    virtual VkResult on_vkGetFenceFdKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkFenceGetFdInfoKHR* pGetFdInfo,
+        int* pFd);
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+    virtual VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+        VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+    virtual VkResult on_vkGetPhysicalDeviceSurfaceFormats2KHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+        uint32_t* pSurfaceFormatCount,
+        VkSurfaceFormat2KHR* pSurfaceFormats);
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+    virtual VkResult on_vkGetPhysicalDeviceDisplayProperties2KHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t* pPropertyCount,
+        VkDisplayProperties2KHR* pProperties);
+    virtual VkResult on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        uint32_t* pPropertyCount,
+        VkDisplayPlaneProperties2KHR* pProperties);
+    virtual VkResult on_vkGetDisplayModeProperties2KHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkDisplayKHR display,
+        uint32_t* pPropertyCount,
+        VkDisplayModeProperties2KHR* pProperties);
+    virtual VkResult on_vkGetDisplayPlaneCapabilities2KHR(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+        VkDisplayPlaneCapabilities2KHR* pCapabilities);
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+    virtual void on_vkGetImageMemoryRequirements2KHR(
+    void* context,
+        VkDevice device,
+        const VkImageMemoryRequirementsInfo2* pInfo,
+        VkMemoryRequirements2* pMemoryRequirements);
+    virtual void on_vkGetBufferMemoryRequirements2KHR(
+    void* context,
+        VkDevice device,
+        const VkBufferMemoryRequirementsInfo2* pInfo,
+        VkMemoryRequirements2* pMemoryRequirements);
+    virtual void on_vkGetImageSparseMemoryRequirements2KHR(
+    void* context,
+        VkDevice device,
+        const VkImageSparseMemoryRequirementsInfo2* pInfo,
+        uint32_t* pSparseMemoryRequirementCount,
+        VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+    virtual VkResult on_vkCreateSamplerYcbcrConversionKHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSamplerYcbcrConversion* pYcbcrConversion);
+    virtual void on_vkDestroySamplerYcbcrConversionKHR(
+    void* context,
+        VkDevice device,
+        VkSamplerYcbcrConversion ycbcrConversion,
+        const VkAllocationCallbacks* pAllocator);
+#endif
+#ifdef VK_KHR_bind_memory2
+    virtual VkResult on_vkBindBufferMemory2KHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t bindInfoCount,
+        const VkBindBufferMemoryInfo* pBindInfos);
+    virtual VkResult on_vkBindImageMemory2KHR(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        uint32_t bindInfoCount,
+        const VkBindImageMemoryInfo* pBindInfos);
+#endif
+#ifdef VK_KHR_maintenance3
+    virtual void on_vkGetDescriptorSetLayoutSupportKHR(
+    void* context,
+        VkDevice device,
+        const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+        VkDescriptorSetLayoutSupport* pSupport);
+#endif
+#ifdef VK_KHR_draw_indirect_count
+    virtual void on_vkCmdDrawIndirectCountKHR(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        VkBuffer countBuffer,
+        VkDeviceSize countBufferOffset,
+        uint32_t maxDrawCount,
+        uint32_t stride);
+    virtual void on_vkCmdDrawIndexedIndirectCountKHR(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        VkBuffer countBuffer,
+        VkDeviceSize countBufferOffset,
+        uint32_t maxDrawCount,
+        uint32_t stride);
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+    virtual VkResult on_vkGetSwapchainGrallocUsageANDROID(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkFormat format,
+        VkImageUsageFlags imageUsage,
+        int* grallocUsage);
+    virtual VkResult on_vkAcquireImageANDROID(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkImage image,
+        int nativeFenceFd,
+        VkSemaphore semaphore,
+        VkFence fence);
+    virtual VkResult on_vkQueueSignalReleaseImageANDROID(
+    void* context,
+        VkResult input_result,
+        VkQueue queue,
+        uint32_t waitSemaphoreCount,
+        const VkSemaphore* pWaitSemaphores,
+        VkImage image,
+        int* pNativeFenceFd);
+#endif
+#ifdef VK_EXT_debug_report
+    virtual VkResult on_vkCreateDebugReportCallbackEXT(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDebugReportCallbackEXT* pCallback);
+    virtual void on_vkDestroyDebugReportCallbackEXT(
+    void* context,
+        VkInstance instance,
+        VkDebugReportCallbackEXT callback,
+        const VkAllocationCallbacks* pAllocator);
+    virtual void on_vkDebugReportMessageEXT(
+    void* context,
+        VkInstance instance,
+        VkDebugReportFlagsEXT flags,
+        VkDebugReportObjectTypeEXT objectType,
+        uint64_t object,
+        size_t location,
+        int32_t messageCode,
+        const char* pLayerPrefix,
+        const char* pMessage);
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+    virtual VkResult on_vkDebugMarkerSetObjectTagEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+    virtual VkResult on_vkDebugMarkerSetObjectNameEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+    virtual void on_vkCmdDebugMarkerBeginEXT(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+    virtual void on_vkCmdDebugMarkerEndEXT(
+    void* context,
+        VkCommandBuffer commandBuffer);
+    virtual void on_vkCmdDebugMarkerInsertEXT(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+    virtual void on_vkCmdDrawIndirectCountAMD(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        VkBuffer countBuffer,
+        VkDeviceSize countBufferOffset,
+        uint32_t maxDrawCount,
+        uint32_t stride);
+    virtual void on_vkCmdDrawIndexedIndirectCountAMD(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkBuffer buffer,
+        VkDeviceSize offset,
+        VkBuffer countBuffer,
+        VkDeviceSize countBufferOffset,
+        uint32_t maxDrawCount,
+        uint32_t stride);
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+    virtual VkResult on_vkGetShaderInfoAMD(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkPipeline pipeline,
+        VkShaderStageFlagBits shaderStage,
+        VkShaderInfoTypeAMD infoType,
+        size_t* pInfoSize,
+        void* pInfo);
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+    virtual VkResult on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkFormat format,
+        VkImageType type,
+        VkImageTiling tiling,
+        VkImageUsageFlags usage,
+        VkImageCreateFlags flags,
+        VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+        VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+    virtual VkResult on_vkGetMemoryWin32HandleNV(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkDeviceMemory memory,
+        VkExternalMemoryHandleTypeFlagsNV handleType,
+        HANDLE* pHandle);
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+    virtual VkResult on_vkCreateViSurfaceNN(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkViSurfaceCreateInfoNN* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+    virtual void on_vkCmdBeginConditionalRenderingEXT(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+    virtual void on_vkCmdEndConditionalRenderingEXT(
+    void* context,
+        VkCommandBuffer commandBuffer);
+#endif
+#ifdef VK_NVX_device_generated_commands
+    virtual void on_vkCmdProcessCommandsNVX(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
+    virtual void on_vkCmdReserveSpaceForCommandsNVX(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
+    virtual VkResult on_vkCreateIndirectCommandsLayoutNVX(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
+    virtual void on_vkDestroyIndirectCommandsLayoutNVX(
+    void* context,
+        VkDevice device,
+        VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkCreateObjectTableNVX(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkObjectTableCreateInfoNVX* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkObjectTableNVX* pObjectTable);
+    virtual void on_vkDestroyObjectTableNVX(
+    void* context,
+        VkDevice device,
+        VkObjectTableNVX objectTable,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkRegisterObjectsNVX(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkObjectTableNVX objectTable,
+        uint32_t objectCount,
+        const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+        const uint32_t* pObjectIndices);
+    virtual VkResult on_vkUnregisterObjectsNVX(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkObjectTableNVX objectTable,
+        uint32_t objectCount,
+        const VkObjectEntryTypeNVX* pObjectEntryTypes,
+        const uint32_t* pObjectIndices);
+    virtual void on_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+        VkDeviceGeneratedCommandsLimitsNVX* pLimits);
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+    virtual void on_vkCmdSetViewportWScalingNV(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t firstViewport,
+        uint32_t viewportCount,
+        const VkViewportWScalingNV* pViewportWScalings);
+#endif
+#ifdef VK_EXT_direct_mode_display
+    virtual VkResult on_vkReleaseDisplayEXT(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkDisplayKHR display);
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+    virtual VkResult on_vkAcquireXlibDisplayEXT(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        Display* dpy,
+        VkDisplayKHR display);
+    virtual VkResult on_vkGetRandROutputDisplayEXT(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        Display* dpy,
+        RROutput rrOutput,
+        VkDisplayKHR* pDisplay);
+#endif
+#ifdef VK_EXT_display_surface_counter
+    virtual VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+    void* context,
+        VkResult input_result,
+        VkPhysicalDevice physicalDevice,
+        VkSurfaceKHR surface,
+        VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
+#endif
+#ifdef VK_EXT_display_control
+    virtual VkResult on_vkDisplayPowerControlEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkDisplayKHR display,
+        const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
+    virtual VkResult on_vkRegisterDeviceEventEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkDeviceEventInfoEXT* pDeviceEventInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkFence* pFence);
+    virtual VkResult on_vkRegisterDisplayEventEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkDisplayKHR display,
+        const VkDisplayEventInfoEXT* pDisplayEventInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkFence* pFence);
+    virtual VkResult on_vkGetSwapchainCounterEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkSwapchainKHR swapchain,
+        VkSurfaceCounterFlagBitsEXT counter,
+        uint64_t* pCounterValue);
+#endif
+#ifdef VK_GOOGLE_display_timing
+    virtual VkResult on_vkGetRefreshCycleDurationGOOGLE(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkSwapchainKHR swapchain,
+        VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
+    virtual VkResult on_vkGetPastPresentationTimingGOOGLE(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkSwapchainKHR swapchain,
+        uint32_t* pPresentationTimingCount,
+        VkPastPresentationTimingGOOGLE* pPresentationTimings);
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+    virtual void on_vkCmdSetDiscardRectangleEXT(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        uint32_t firstDiscardRectangle,
+        uint32_t discardRectangleCount,
+        const VkRect2D* pDiscardRectangles);
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+    virtual void on_vkSetHdrMetadataEXT(
+    void* context,
+        VkDevice device,
+        uint32_t swapchainCount,
+        const VkSwapchainKHR* pSwapchains,
+        const VkHdrMetadataEXT* pMetadata);
+#endif
+#ifdef VK_MVK_ios_surface
+    virtual VkResult on_vkCreateIOSSurfaceMVK(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_MVK_macos_surface
+    virtual VkResult on_vkCreateMacOSSurfaceMVK(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+    virtual VkResult on_vkSetDebugUtilsObjectNameEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
+    virtual VkResult on_vkSetDebugUtilsObjectTagEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
+    virtual void on_vkQueueBeginDebugUtilsLabelEXT(
+    void* context,
+        VkQueue queue,
+        const VkDebugUtilsLabelEXT* pLabelInfo);
+    virtual void on_vkQueueEndDebugUtilsLabelEXT(
+    void* context,
+        VkQueue queue);
+    virtual void on_vkQueueInsertDebugUtilsLabelEXT(
+    void* context,
+        VkQueue queue,
+        const VkDebugUtilsLabelEXT* pLabelInfo);
+    virtual void on_vkCmdBeginDebugUtilsLabelEXT(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkDebugUtilsLabelEXT* pLabelInfo);
+    virtual void on_vkCmdEndDebugUtilsLabelEXT(
+    void* context,
+        VkCommandBuffer commandBuffer);
+    virtual void on_vkCmdInsertDebugUtilsLabelEXT(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkDebugUtilsLabelEXT* pLabelInfo);
+    virtual VkResult on_vkCreateDebugUtilsMessengerEXT(
+    void* context,
+        VkResult input_result,
+        VkInstance instance,
+        const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDebugUtilsMessengerEXT* pMessenger);
+    virtual void on_vkDestroyDebugUtilsMessengerEXT(
+    void* context,
+        VkInstance instance,
+        VkDebugUtilsMessengerEXT messenger,
+        const VkAllocationCallbacks* pAllocator);
+    virtual void on_vkSubmitDebugUtilsMessageEXT(
+    void* context,
+        VkInstance instance,
+        VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+        VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+        const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+    virtual VkResult on_vkGetAndroidHardwareBufferPropertiesANDROID(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const AHardwareBuffer* buffer,
+        VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+    virtual VkResult on_vkGetMemoryAndroidHardwareBufferANDROID(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+        AHardwareBuffer** pBuffer);
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+    virtual void on_vkCmdSetSampleLocationsEXT(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
+    virtual void on_vkGetPhysicalDeviceMultisamplePropertiesEXT(
+    void* context,
+        VkPhysicalDevice physicalDevice,
+        VkSampleCountFlagBits samples,
+        VkMultisamplePropertiesEXT* pMultisampleProperties);
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+    virtual VkResult on_vkCreateValidationCacheEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        const VkValidationCacheCreateInfoEXT* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkValidationCacheEXT* pValidationCache);
+    virtual void on_vkDestroyValidationCacheEXT(
+    void* context,
+        VkDevice device,
+        VkValidationCacheEXT validationCache,
+        const VkAllocationCallbacks* pAllocator);
+    virtual VkResult on_vkMergeValidationCachesEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkValidationCacheEXT dstCache,
+        uint32_t srcCacheCount,
+        const VkValidationCacheEXT* pSrcCaches);
+    virtual VkResult on_vkGetValidationCacheDataEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkValidationCacheEXT validationCache,
+        size_t* pDataSize,
+        void* pData);
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+    virtual VkResult on_vkGetMemoryHostPointerPropertiesEXT(
+    void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkExternalMemoryHandleTypeFlagBits handleType,
+        const void* pHostPointer,
+        VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
+#endif
+#ifdef VK_AMD_buffer_marker
+    virtual void on_vkCmdWriteBufferMarkerAMD(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        VkPipelineStageFlagBits pipelineStage,
+        VkBuffer dstBuffer,
+        VkDeviceSize dstOffset,
+        uint32_t marker);
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+    virtual void on_vkCmdSetCheckpointNV(
+    void* context,
+        VkCommandBuffer commandBuffer,
+        const void* pCheckpointMarker);
+    virtual void on_vkGetQueueCheckpointDataNV(
+    void* context,
+        VkQueue queue,
+        uint32_t* pCheckpointDataCount,
+        VkCheckpointDataNV* pCheckpointData);
+#endif
+
+};
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VulkanHandleMapping.cpp b/system/vulkan_enc/VulkanHandleMapping.cpp
new file mode 100644
index 0000000..649244f
--- /dev/null
+++ b/system/vulkan_enc/VulkanHandleMapping.cpp
@@ -0,0 +1,33 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include <vulkan/vulkan.h>
+
+#include "VulkanHandleMapping.h"
+
+namespace goldfish_vk {
+
+#define DEFAULT_HANDLE_MAP_DEFINE(type) \
+void DefaultHandleMapping::mapHandles_##type(type*, size_t) { return; } \
+void DefaultHandleMapping::mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count) { \
+    for (size_t i = 0; i < count; ++i) { handle_u64s[i] = (uint64_t)(uintptr_t)handles[i]; } \
+} \
+void DefaultHandleMapping::mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count) { \
+    for (size_t i = 0; i < count; ++i) { handles[i] = (type)(uintptr_t)handle_u64s[i]; } \
+} \
+
+GOLDFISH_VK_LIST_HANDLE_TYPES(DEFAULT_HANDLE_MAP_DEFINE)
+
+} // namespace goldfish_vk
+
diff --git a/system/vulkan_enc/VulkanHandleMapping.h b/system/vulkan_enc/VulkanHandleMapping.h
new file mode 100644
index 0000000..5c03d7f
--- /dev/null
+++ b/system/vulkan_enc/VulkanHandleMapping.h
@@ -0,0 +1,48 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#include "VulkanHandles.h"
+
+namespace goldfish_vk {
+
+class VulkanHandleMapping {
+public:
+    VulkanHandleMapping() = default;
+    virtual ~VulkanHandleMapping() { }
+
+#define DECLARE_HANDLE_MAP_PURE_VIRTUAL_METHOD(type) \
+    virtual void mapHandles_##type(type* handles, size_t count = 1) = 0; \
+    virtual void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count = 1) = 0; \
+    virtual void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count = 1) = 0; \
+
+    GOLDFISH_VK_LIST_HANDLE_TYPES(DECLARE_HANDLE_MAP_PURE_VIRTUAL_METHOD)
+};
+
+class DefaultHandleMapping : public VulkanHandleMapping {
+public:
+    virtual ~DefaultHandleMapping() { }
+
+#define DECLARE_HANDLE_MAP_OVERRIDE(type) \
+    void mapHandles_##type(type* handles, size_t count) override; \
+    void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count) override; \
+    void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count) override; \
+
+    GOLDFISH_VK_LIST_HANDLE_TYPES(DECLARE_HANDLE_MAP_OVERRIDE)
+};
+
+} // namespace goldfish_vk
\ No newline at end of file
diff --git a/system/vulkan_enc/VulkanHandles.h b/system/vulkan_enc/VulkanHandles.h
new file mode 100644
index 0000000..af130eb
--- /dev/null
+++ b/system/vulkan_enc/VulkanHandles.h
@@ -0,0 +1,71 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#define GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
+    f(VkInstance) \
+    f(VkPhysicalDevice) \
+    f(VkQueue) \
+    f(VkCommandBuffer) \
+
+#define GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(f) \
+    f(VkDevice) \
+    GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f)
+
+#define GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+    f(VkBuffer) \
+    f(VkBufferView) \
+    f(VkImage) \
+    f(VkImageView) \
+    f(VkShaderModule) \
+    f(VkDescriptorPool) \
+    f(VkDescriptorSetLayout) \
+    f(VkDescriptorSet) \
+    f(VkSampler) \
+    f(VkPipeline) \
+    f(VkPipelineCache) \
+    f(VkPipelineLayout) \
+    f(VkRenderPass) \
+    f(VkFramebuffer) \
+    f(VkCommandPool) \
+    f(VkFence) \
+    f(VkSemaphore) \
+    f(VkEvent) \
+    f(VkQueryPool) \
+    f(VkSamplerYcbcrConversion) \
+    f(VkDescriptorUpdateTemplate) \
+    f(VkSurfaceKHR) \
+    f(VkSwapchainKHR) \
+    f(VkDisplayKHR) \
+    f(VkDisplayModeKHR) \
+    f(VkObjectTableNVX) \
+    f(VkIndirectCommandsLayoutNVX) \
+    f(VkValidationCacheEXT) \
+    f(VkDebugReportCallbackEXT) \
+    f(VkDebugUtilsMessengerEXT) \
+
+#define GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+    f(VkDeviceMemory) \
+    GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+
+#define GOLDFISH_VK_LIST_HANDLE_TYPES(f) \
+    GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(f) \
+    GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f)
+
+#define GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(f) \
+    GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
+    GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f)
diff --git a/system/vulkan_enc/VulkanStream.cpp b/system/vulkan_enc/VulkanStream.cpp
new file mode 100644
index 0000000..f862bf7
--- /dev/null
+++ b/system/vulkan_enc/VulkanStream.cpp
@@ -0,0 +1,200 @@
+// Copyright (C) 2018 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 "VulkanStream.h"
+
+#include "IOStream.h"
+
+#include "android/base/Pool.h"
+
+#include <vector>
+
+#include <cutils/log.h>
+#include <inttypes.h>
+
+namespace goldfish_vk {
+
+class VulkanStream::Impl : public android::base::Stream {
+public:
+    Impl(IOStream* stream) : mStream(stream) { unsetHandleMapping(); }
+
+    ~Impl() { }
+
+    bool valid() { return true; }
+
+    void alloc(void **ptrAddr, size_t bytes) {
+        if (!bytes) {
+            *ptrAddr = nullptr;
+            return;
+        }
+
+        *ptrAddr = mPool.alloc(bytes);
+    }
+
+    ssize_t write(const void *buffer, size_t size) override {
+        return bufferedWrite(buffer, size);
+    }
+
+    ssize_t read(void *buffer, size_t size) override {
+        commitWrite();
+        if (!mStream->readFully(buffer, size)) {
+            ALOGE("FATAL: Could not read back %zu bytes", size);
+            abort();
+        }
+        return size;
+    }
+
+    void clearPool() {
+        mPool.freeAll();
+    }
+
+    void setHandleMapping(VulkanHandleMapping* mapping) {
+        mCurrentHandleMapping = mapping;
+    }
+
+    void unsetHandleMapping() {
+        mCurrentHandleMapping = &mDefaultHandleMapping;
+    }
+
+    VulkanHandleMapping* handleMapping() const {
+        return mCurrentHandleMapping;
+    }
+
+private:
+    size_t oustandingWriteBuffer() const {
+        return mWritePos;
+    }
+
+    size_t remainingWriteBufferSize() const {
+        return mWriteBuffer.size() - mWritePos;
+    }
+
+    void commitWrite() {
+        if (!valid()) {
+            ALOGE("FATAL: Tried to commit write to vulkan pipe with invalid pipe!");
+            abort();
+        }
+
+        int written =
+            mStream->writeFully(mWriteBuffer.data(), mWritePos);
+
+        if (written) {
+            ALOGE("FATAL: Did not write exactly %zu bytes!",
+                  mWritePos);
+            abort();
+        }
+        mWritePos = 0;
+    }
+
+    ssize_t bufferedWrite(const void *buffer, size_t size) {
+        if (size > remainingWriteBufferSize()) {
+            mWriteBuffer.resize((mWritePos + size) << 1);
+        }
+        memcpy(mWriteBuffer.data() + mWritePos, buffer, size);
+        mWritePos += size;
+        return size;
+    }
+
+    android::base::Pool mPool { 8, 4096, 64 };
+
+    size_t mWritePos = 0;
+    std::vector<uint8_t> mWriteBuffer;
+    IOStream* mStream = nullptr;
+    DefaultHandleMapping mDefaultHandleMapping;
+    VulkanHandleMapping* mCurrentHandleMapping;
+};
+
+VulkanStream::VulkanStream(IOStream *stream) :
+    mImpl(new VulkanStream::Impl(stream)) { }
+
+VulkanStream::~VulkanStream() = default;
+
+bool VulkanStream::valid() {
+    return mImpl->valid();
+}
+
+void VulkanStream::alloc(void** ptrAddr, size_t bytes) {
+    mImpl->alloc(ptrAddr, bytes);
+}
+
+void VulkanStream::loadStringInPlace(char** forOutput) {
+    size_t len = getBe32();
+
+    alloc((void**)forOutput, len + 1);
+
+    memset(*forOutput, 0x0, len + 1);
+
+    if (len > 0) read(*forOutput, len);
+}
+
+void VulkanStream::loadStringArrayInPlace(char*** forOutput) {
+    size_t count = getBe32();
+
+    if (!count) {
+        *forOutput = nullptr;
+        return;
+    }
+
+    alloc((void**)forOutput, count * sizeof(char*));
+
+    char **stringsForOutput = *forOutput;
+
+    for (size_t i = 0; i < count; i++) {
+        loadStringInPlace(stringsForOutput + i);
+    }
+}
+
+
+ssize_t VulkanStream::read(void *buffer, size_t size) {
+    return mImpl->read(buffer, size);
+}
+
+ssize_t VulkanStream::write(const void *buffer, size_t size) {
+    return mImpl->write(buffer, size);
+}
+
+void VulkanStream::clearPool() {
+    mImpl->clearPool();
+}
+
+void VulkanStream::setHandleMapping(VulkanHandleMapping* mapping) {
+    mImpl->setHandleMapping(mapping);
+}
+
+void VulkanStream::unsetHandleMapping() {
+    mImpl->unsetHandleMapping();
+}
+
+VulkanHandleMapping* VulkanStream::handleMapping() const {
+    return mImpl->handleMapping();
+}
+
+VulkanCountingStream::VulkanCountingStream() : VulkanStream(nullptr) { }
+VulkanCountingStream::~VulkanCountingStream() = default;
+
+ssize_t VulkanCountingStream::read(void*, size_t size) {
+    m_read += size;
+    return size;
+}
+
+ssize_t VulkanCountingStream::write(const void*, size_t size) {
+    m_written += size;
+    return size;
+}
+
+void VulkanCountingStream::rewind() {
+    m_written = 0;
+    m_read = 0;
+}
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VulkanStream.h b/system/vulkan_enc/VulkanStream.h
new file mode 100644
index 0000000..b763f32
--- /dev/null
+++ b/system/vulkan_enc/VulkanStream.h
@@ -0,0 +1,75 @@
+// Copyright (C) 2018 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.
+#pragma once
+
+#include "android/base/files/Stream.h"
+#include "android/base/files/StreamSerializing.h"
+
+#include "VulkanHandleMapping.h"
+
+#include <memory>
+
+class IOStream;
+
+namespace goldfish_vk {
+
+class VulkanStream : public android::base::Stream {
+public:
+    VulkanStream(IOStream* stream);
+    ~VulkanStream();
+
+    // Returns whether the connection is valid.
+    bool valid();
+
+    // General allocation function
+    void alloc(void** ptrAddr, size_t bytes);
+
+    // Utility functions to load strings or
+    // string arrays in place with allocation.
+    void loadStringInPlace(char** forOutput);
+    void loadStringArrayInPlace(char*** forOutput);
+
+    ssize_t read(void *buffer, size_t size) override;
+    ssize_t write(const void *buffer, size_t size) override;
+
+    // Frees everything that got alloc'ed.
+    void clearPool();
+
+    void setHandleMapping(VulkanHandleMapping* mapping);
+    void unsetHandleMapping();
+    VulkanHandleMapping* handleMapping() const;
+
+private:
+    class Impl;
+    std::unique_ptr<Impl> mImpl;
+};
+
+class VulkanCountingStream : public VulkanStream {
+public:
+    VulkanCountingStream();
+    ~VulkanCountingStream();
+
+    ssize_t read(void *buffer, size_t size) override;
+    ssize_t write(const void *buffer, size_t size) override;
+
+    size_t bytesWritten() const { return m_written; }
+    size_t bytesRead() const { return m_read; }
+
+    void rewind();
+private:
+    size_t m_written = 0;
+    size_t m_read = 0;
+};
+
+} // namespace goldfish_vk
\ No newline at end of file
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
new file mode 100644
index 0000000..c481e3c
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -0,0 +1,7000 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_deepcopy_guest
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "goldfish_vk_deepcopy_guest.h"
+
+
+#include "goldfish_vk_extension_structs_guest.h"
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+void deepcopy_extension_struct(
+    Pool* pool,
+    const void* structExtension,
+    void* structExtension_out);
+
+#ifdef VK_VERSION_1_0
+void deepcopy_VkApplicationInfo(
+    Pool* pool,
+    const VkApplicationInfo* from,
+    VkApplicationInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pApplicationName = nullptr;
+    if (from->pApplicationName)
+    {
+        to->pApplicationName = pool->strDup(from->pApplicationName);
+    }
+    to->pEngineName = nullptr;
+    if (from->pEngineName)
+    {
+        to->pEngineName = pool->strDup(from->pEngineName);
+    }
+}
+
+void deepcopy_VkInstanceCreateInfo(
+    Pool* pool,
+    const VkInstanceCreateInfo* from,
+    VkInstanceCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pApplicationInfo = nullptr;
+    if (from->pApplicationInfo)
+    {
+        to->pApplicationInfo = (VkApplicationInfo*)pool->alloc(sizeof(const VkApplicationInfo));
+        deepcopy_VkApplicationInfo(pool, from->pApplicationInfo, (VkApplicationInfo*)(to->pApplicationInfo));
+    }
+    to->ppEnabledLayerNames = nullptr;
+    if (from->ppEnabledLayerNames && from->enabledLayerCount)
+    {
+        to->ppEnabledLayerNames = pool->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
+    }
+    to->ppEnabledExtensionNames = nullptr;
+    if (from->ppEnabledExtensionNames && from->enabledExtensionCount)
+    {
+        to->ppEnabledExtensionNames = pool->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
+    }
+}
+
+void deepcopy_VkAllocationCallbacks(
+    Pool* pool,
+    const VkAllocationCallbacks* from,
+    VkAllocationCallbacks* to)
+{
+    (void)pool;
+    *to = *from;
+    to->pUserData = nullptr;
+    if (from->pUserData)
+    {
+        to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceFeatures* from,
+    VkPhysicalDeviceFeatures* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkFormatProperties(
+    Pool* pool,
+    const VkFormatProperties* from,
+    VkFormatProperties* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkExtent3D(
+    Pool* pool,
+    const VkExtent3D* from,
+    VkExtent3D* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkImageFormatProperties(
+    Pool* pool,
+    const VkImageFormatProperties* from,
+    VkImageFormatProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkExtent3D(pool, &from->maxExtent, (VkExtent3D*)(&to->maxExtent));
+}
+
+void deepcopy_VkPhysicalDeviceLimits(
+    Pool* pool,
+    const VkPhysicalDeviceLimits* from,
+    VkPhysicalDeviceLimits* to)
+{
+    (void)pool;
+    *to = *from;
+    memcpy(to->maxComputeWorkGroupCount, from->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
+    memcpy(to->maxComputeWorkGroupSize, from->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
+    memcpy(to->maxViewportDimensions, from->maxViewportDimensions, 2 * sizeof(uint32_t));
+    memcpy(to->viewportBoundsRange, from->viewportBoundsRange, 2 * sizeof(float));
+    memcpy(to->pointSizeRange, from->pointSizeRange, 2 * sizeof(float));
+    memcpy(to->lineWidthRange, from->lineWidthRange, 2 * sizeof(float));
+}
+
+void deepcopy_VkPhysicalDeviceSparseProperties(
+    Pool* pool,
+    const VkPhysicalDeviceSparseProperties* from,
+    VkPhysicalDeviceSparseProperties* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPhysicalDeviceProperties(
+    Pool* pool,
+    const VkPhysicalDeviceProperties* from,
+    VkPhysicalDeviceProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    memcpy(to->deviceName, from->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
+    memcpy(to->pipelineCacheUUID, from->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    deepcopy_VkPhysicalDeviceLimits(pool, &from->limits, (VkPhysicalDeviceLimits*)(&to->limits));
+    deepcopy_VkPhysicalDeviceSparseProperties(pool, &from->sparseProperties, (VkPhysicalDeviceSparseProperties*)(&to->sparseProperties));
+}
+
+void deepcopy_VkQueueFamilyProperties(
+    Pool* pool,
+    const VkQueueFamilyProperties* from,
+    VkQueueFamilyProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkExtent3D(pool, &from->minImageTransferGranularity, (VkExtent3D*)(&to->minImageTransferGranularity));
+}
+
+void deepcopy_VkMemoryType(
+    Pool* pool,
+    const VkMemoryType* from,
+    VkMemoryType* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkMemoryHeap(
+    Pool* pool,
+    const VkMemoryHeap* from,
+    VkMemoryHeap* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPhysicalDeviceMemoryProperties(
+    Pool* pool,
+    const VkPhysicalDeviceMemoryProperties* from,
+    VkPhysicalDeviceMemoryProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
+    {
+        deepcopy_VkMemoryType(pool, from->memoryTypes + i, (VkMemoryType*)(to->memoryTypes + i));
+    }
+    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
+    {
+        deepcopy_VkMemoryHeap(pool, from->memoryHeaps + i, (VkMemoryHeap*)(to->memoryHeaps + i));
+    }
+}
+
+void deepcopy_VkDeviceQueueCreateInfo(
+    Pool* pool,
+    const VkDeviceQueueCreateInfo* from,
+    VkDeviceQueueCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pQueuePriorities = nullptr;
+    if (from->pQueuePriorities)
+    {
+        to->pQueuePriorities = (float*)pool->dupArray(from->pQueuePriorities, from->queueCount * sizeof(const float));
+    }
+}
+
+void deepcopy_VkDeviceCreateInfo(
+    Pool* pool,
+    const VkDeviceCreateInfo* from,
+    VkDeviceCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pQueueCreateInfos = nullptr;
+    if (from->pQueueCreateInfos)
+    {
+        to->pQueueCreateInfos = (VkDeviceQueueCreateInfo*)pool->alloc(from->queueCreateInfoCount * sizeof(const VkDeviceQueueCreateInfo));
+        to->queueCreateInfoCount = from->queueCreateInfoCount;
+        for (uint32_t i = 0; i < (uint32_t)from->queueCreateInfoCount; ++i)
+        {
+            deepcopy_VkDeviceQueueCreateInfo(pool, from->pQueueCreateInfos + i, (VkDeviceQueueCreateInfo*)(to->pQueueCreateInfos + i));
+        }
+    }
+    to->ppEnabledLayerNames = nullptr;
+    if (from->ppEnabledLayerNames && from->enabledLayerCount)
+    {
+        to->ppEnabledLayerNames = pool->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
+    }
+    to->ppEnabledExtensionNames = nullptr;
+    if (from->ppEnabledExtensionNames && from->enabledExtensionCount)
+    {
+        to->ppEnabledExtensionNames = pool->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
+    }
+    to->pEnabledFeatures = nullptr;
+    if (from->pEnabledFeatures)
+    {
+        to->pEnabledFeatures = (VkPhysicalDeviceFeatures*)pool->alloc(sizeof(const VkPhysicalDeviceFeatures));
+        deepcopy_VkPhysicalDeviceFeatures(pool, from->pEnabledFeatures, (VkPhysicalDeviceFeatures*)(to->pEnabledFeatures));
+    }
+}
+
+void deepcopy_VkExtensionProperties(
+    Pool* pool,
+    const VkExtensionProperties* from,
+    VkExtensionProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    memcpy(to->extensionName, from->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+}
+
+void deepcopy_VkLayerProperties(
+    Pool* pool,
+    const VkLayerProperties* from,
+    VkLayerProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    memcpy(to->layerName, from->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+}
+
+void deepcopy_VkSubmitInfo(
+    Pool* pool,
+    const VkSubmitInfo* from,
+    VkSubmitInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pWaitSemaphores = nullptr;
+    if (from->pWaitSemaphores)
+    {
+        to->pWaitSemaphores = (VkSemaphore*)pool->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
+    }
+    to->pWaitDstStageMask = nullptr;
+    if (from->pWaitDstStageMask)
+    {
+        to->pWaitDstStageMask = (VkPipelineStageFlags*)pool->dupArray(from->pWaitDstStageMask, from->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+    }
+    to->pCommandBuffers = nullptr;
+    if (from->pCommandBuffers)
+    {
+        to->pCommandBuffers = (VkCommandBuffer*)pool->dupArray(from->pCommandBuffers, from->commandBufferCount * sizeof(const VkCommandBuffer));
+    }
+    to->pSignalSemaphores = nullptr;
+    if (from->pSignalSemaphores)
+    {
+        to->pSignalSemaphores = (VkSemaphore*)pool->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
+    }
+}
+
+void deepcopy_VkMemoryAllocateInfo(
+    Pool* pool,
+    const VkMemoryAllocateInfo* from,
+    VkMemoryAllocateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMappedMemoryRange(
+    Pool* pool,
+    const VkMappedMemoryRange* from,
+    VkMappedMemoryRange* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMemoryRequirements(
+    Pool* pool,
+    const VkMemoryRequirements* from,
+    VkMemoryRequirements* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkSparseImageFormatProperties(
+    Pool* pool,
+    const VkSparseImageFormatProperties* from,
+    VkSparseImageFormatProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkExtent3D(pool, &from->imageGranularity, (VkExtent3D*)(&to->imageGranularity));
+}
+
+void deepcopy_VkSparseImageMemoryRequirements(
+    Pool* pool,
+    const VkSparseImageMemoryRequirements* from,
+    VkSparseImageMemoryRequirements* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkSparseImageFormatProperties(pool, &from->formatProperties, (VkSparseImageFormatProperties*)(&to->formatProperties));
+}
+
+void deepcopy_VkSparseMemoryBind(
+    Pool* pool,
+    const VkSparseMemoryBind* from,
+    VkSparseMemoryBind* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkSparseBufferMemoryBindInfo(
+    Pool* pool,
+    const VkSparseBufferMemoryBindInfo* from,
+    VkSparseBufferMemoryBindInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    to->pBinds = nullptr;
+    if (from->pBinds)
+    {
+        to->pBinds = (VkSparseMemoryBind*)pool->alloc(from->bindCount * sizeof(const VkSparseMemoryBind));
+        to->bindCount = from->bindCount;
+        for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i)
+        {
+            deepcopy_VkSparseMemoryBind(pool, from->pBinds + i, (VkSparseMemoryBind*)(to->pBinds + i));
+        }
+    }
+}
+
+void deepcopy_VkSparseImageOpaqueMemoryBindInfo(
+    Pool* pool,
+    const VkSparseImageOpaqueMemoryBindInfo* from,
+    VkSparseImageOpaqueMemoryBindInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    to->pBinds = nullptr;
+    if (from->pBinds)
+    {
+        to->pBinds = (VkSparseMemoryBind*)pool->alloc(from->bindCount * sizeof(const VkSparseMemoryBind));
+        to->bindCount = from->bindCount;
+        for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i)
+        {
+            deepcopy_VkSparseMemoryBind(pool, from->pBinds + i, (VkSparseMemoryBind*)(to->pBinds + i));
+        }
+    }
+}
+
+void deepcopy_VkImageSubresource(
+    Pool* pool,
+    const VkImageSubresource* from,
+    VkImageSubresource* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkOffset3D(
+    Pool* pool,
+    const VkOffset3D* from,
+    VkOffset3D* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkSparseImageMemoryBind(
+    Pool* pool,
+    const VkSparseImageMemoryBind* from,
+    VkSparseImageMemoryBind* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkImageSubresource(pool, &from->subresource, (VkImageSubresource*)(&to->subresource));
+    deepcopy_VkOffset3D(pool, &from->offset, (VkOffset3D*)(&to->offset));
+    deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
+}
+
+void deepcopy_VkSparseImageMemoryBindInfo(
+    Pool* pool,
+    const VkSparseImageMemoryBindInfo* from,
+    VkSparseImageMemoryBindInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    to->pBinds = nullptr;
+    if (from->pBinds)
+    {
+        to->pBinds = (VkSparseImageMemoryBind*)pool->alloc(from->bindCount * sizeof(const VkSparseImageMemoryBind));
+        to->bindCount = from->bindCount;
+        for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i)
+        {
+            deepcopy_VkSparseImageMemoryBind(pool, from->pBinds + i, (VkSparseImageMemoryBind*)(to->pBinds + i));
+        }
+    }
+}
+
+void deepcopy_VkBindSparseInfo(
+    Pool* pool,
+    const VkBindSparseInfo* from,
+    VkBindSparseInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pWaitSemaphores = nullptr;
+    if (from->pWaitSemaphores)
+    {
+        to->pWaitSemaphores = (VkSemaphore*)pool->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
+    }
+    to->pBufferBinds = nullptr;
+    if (from->pBufferBinds)
+    {
+        to->pBufferBinds = (VkSparseBufferMemoryBindInfo*)pool->alloc(from->bufferBindCount * sizeof(const VkSparseBufferMemoryBindInfo));
+        to->bufferBindCount = from->bufferBindCount;
+        for (uint32_t i = 0; i < (uint32_t)from->bufferBindCount; ++i)
+        {
+            deepcopy_VkSparseBufferMemoryBindInfo(pool, from->pBufferBinds + i, (VkSparseBufferMemoryBindInfo*)(to->pBufferBinds + i));
+        }
+    }
+    to->pImageOpaqueBinds = nullptr;
+    if (from->pImageOpaqueBinds)
+    {
+        to->pImageOpaqueBinds = (VkSparseImageOpaqueMemoryBindInfo*)pool->alloc(from->imageOpaqueBindCount * sizeof(const VkSparseImageOpaqueMemoryBindInfo));
+        to->imageOpaqueBindCount = from->imageOpaqueBindCount;
+        for (uint32_t i = 0; i < (uint32_t)from->imageOpaqueBindCount; ++i)
+        {
+            deepcopy_VkSparseImageOpaqueMemoryBindInfo(pool, from->pImageOpaqueBinds + i, (VkSparseImageOpaqueMemoryBindInfo*)(to->pImageOpaqueBinds + i));
+        }
+    }
+    to->pImageBinds = nullptr;
+    if (from->pImageBinds)
+    {
+        to->pImageBinds = (VkSparseImageMemoryBindInfo*)pool->alloc(from->imageBindCount * sizeof(const VkSparseImageMemoryBindInfo));
+        to->imageBindCount = from->imageBindCount;
+        for (uint32_t i = 0; i < (uint32_t)from->imageBindCount; ++i)
+        {
+            deepcopy_VkSparseImageMemoryBindInfo(pool, from->pImageBinds + i, (VkSparseImageMemoryBindInfo*)(to->pImageBinds + i));
+        }
+    }
+    to->pSignalSemaphores = nullptr;
+    if (from->pSignalSemaphores)
+    {
+        to->pSignalSemaphores = (VkSemaphore*)pool->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
+    }
+}
+
+void deepcopy_VkFenceCreateInfo(
+    Pool* pool,
+    const VkFenceCreateInfo* from,
+    VkFenceCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSemaphoreCreateInfo(
+    Pool* pool,
+    const VkSemaphoreCreateInfo* from,
+    VkSemaphoreCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkEventCreateInfo(
+    Pool* pool,
+    const VkEventCreateInfo* from,
+    VkEventCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkQueryPoolCreateInfo(
+    Pool* pool,
+    const VkQueryPoolCreateInfo* from,
+    VkQueryPoolCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBufferCreateInfo(
+    Pool* pool,
+    const VkBufferCreateInfo* from,
+    VkBufferCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pQueueFamilyIndices = nullptr;
+    if (from->pQueueFamilyIndices)
+    {
+        to->pQueueFamilyIndices = (uint32_t*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkBufferViewCreateInfo(
+    Pool* pool,
+    const VkBufferViewCreateInfo* from,
+    VkBufferViewCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImageCreateInfo(
+    Pool* pool,
+    const VkImageCreateInfo* from,
+    VkImageCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
+    to->pQueueFamilyIndices = nullptr;
+    if (from->pQueueFamilyIndices)
+    {
+        to->pQueueFamilyIndices = (uint32_t*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkSubresourceLayout(
+    Pool* pool,
+    const VkSubresourceLayout* from,
+    VkSubresourceLayout* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkComponentMapping(
+    Pool* pool,
+    const VkComponentMapping* from,
+    VkComponentMapping* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkImageSubresourceRange(
+    Pool* pool,
+    const VkImageSubresourceRange* from,
+    VkImageSubresourceRange* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkImageViewCreateInfo(
+    Pool* pool,
+    const VkImageViewCreateInfo* from,
+    VkImageViewCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkComponentMapping(pool, &from->components, (VkComponentMapping*)(&to->components));
+    deepcopy_VkImageSubresourceRange(pool, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
+}
+
+void deepcopy_VkShaderModuleCreateInfo(
+    Pool* pool,
+    const VkShaderModuleCreateInfo* from,
+    VkShaderModuleCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pCode = nullptr;
+    if (from->pCode)
+    {
+        to->pCode = (uint32_t*)pool->dupArray(from->pCode, (from->codeSize / 4) * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkPipelineCacheCreateInfo(
+    Pool* pool,
+    const VkPipelineCacheCreateInfo* from,
+    VkPipelineCacheCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pInitialData = nullptr;
+    if (from->pInitialData)
+    {
+        to->pInitialData = (void*)pool->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
+    }
+}
+
+void deepcopy_VkSpecializationMapEntry(
+    Pool* pool,
+    const VkSpecializationMapEntry* from,
+    VkSpecializationMapEntry* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkSpecializationInfo(
+    Pool* pool,
+    const VkSpecializationInfo* from,
+    VkSpecializationInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    to->pMapEntries = nullptr;
+    if (from->pMapEntries)
+    {
+        to->pMapEntries = (VkSpecializationMapEntry*)pool->alloc(from->mapEntryCount * sizeof(const VkSpecializationMapEntry));
+        to->mapEntryCount = from->mapEntryCount;
+        for (uint32_t i = 0; i < (uint32_t)from->mapEntryCount; ++i)
+        {
+            deepcopy_VkSpecializationMapEntry(pool, from->pMapEntries + i, (VkSpecializationMapEntry*)(to->pMapEntries + i));
+        }
+    }
+    to->pData = nullptr;
+    if (from->pData)
+    {
+        to->pData = (void*)pool->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
+    }
+}
+
+void deepcopy_VkPipelineShaderStageCreateInfo(
+    Pool* pool,
+    const VkPipelineShaderStageCreateInfo* from,
+    VkPipelineShaderStageCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pName = nullptr;
+    if (from->pName)
+    {
+        to->pName = pool->strDup(from->pName);
+    }
+    to->pSpecializationInfo = nullptr;
+    if (from->pSpecializationInfo)
+    {
+        to->pSpecializationInfo = (VkSpecializationInfo*)pool->alloc(sizeof(const VkSpecializationInfo));
+        deepcopy_VkSpecializationInfo(pool, from->pSpecializationInfo, (VkSpecializationInfo*)(to->pSpecializationInfo));
+    }
+}
+
+void deepcopy_VkVertexInputBindingDescription(
+    Pool* pool,
+    const VkVertexInputBindingDescription* from,
+    VkVertexInputBindingDescription* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkVertexInputAttributeDescription(
+    Pool* pool,
+    const VkVertexInputAttributeDescription* from,
+    VkVertexInputAttributeDescription* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPipelineVertexInputStateCreateInfo(
+    Pool* pool,
+    const VkPipelineVertexInputStateCreateInfo* from,
+    VkPipelineVertexInputStateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pVertexBindingDescriptions = nullptr;
+    if (from->pVertexBindingDescriptions)
+    {
+        to->pVertexBindingDescriptions = (VkVertexInputBindingDescription*)pool->alloc(from->vertexBindingDescriptionCount * sizeof(const VkVertexInputBindingDescription));
+        to->vertexBindingDescriptionCount = from->vertexBindingDescriptionCount;
+        for (uint32_t i = 0; i < (uint32_t)from->vertexBindingDescriptionCount; ++i)
+        {
+            deepcopy_VkVertexInputBindingDescription(pool, from->pVertexBindingDescriptions + i, (VkVertexInputBindingDescription*)(to->pVertexBindingDescriptions + i));
+        }
+    }
+    to->pVertexAttributeDescriptions = nullptr;
+    if (from->pVertexAttributeDescriptions)
+    {
+        to->pVertexAttributeDescriptions = (VkVertexInputAttributeDescription*)pool->alloc(from->vertexAttributeDescriptionCount * sizeof(const VkVertexInputAttributeDescription));
+        to->vertexAttributeDescriptionCount = from->vertexAttributeDescriptionCount;
+        for (uint32_t i = 0; i < (uint32_t)from->vertexAttributeDescriptionCount; ++i)
+        {
+            deepcopy_VkVertexInputAttributeDescription(pool, from->pVertexAttributeDescriptions + i, (VkVertexInputAttributeDescription*)(to->pVertexAttributeDescriptions + i));
+        }
+    }
+}
+
+void deepcopy_VkPipelineInputAssemblyStateCreateInfo(
+    Pool* pool,
+    const VkPipelineInputAssemblyStateCreateInfo* from,
+    VkPipelineInputAssemblyStateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineTessellationStateCreateInfo(
+    Pool* pool,
+    const VkPipelineTessellationStateCreateInfo* from,
+    VkPipelineTessellationStateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkViewport(
+    Pool* pool,
+    const VkViewport* from,
+    VkViewport* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkOffset2D(
+    Pool* pool,
+    const VkOffset2D* from,
+    VkOffset2D* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkExtent2D(
+    Pool* pool,
+    const VkExtent2D* from,
+    VkExtent2D* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkRect2D(
+    Pool* pool,
+    const VkRect2D* from,
+    VkRect2D* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkOffset2D(pool, &from->offset, (VkOffset2D*)(&to->offset));
+    deepcopy_VkExtent2D(pool, &from->extent, (VkExtent2D*)(&to->extent));
+}
+
+void deepcopy_VkPipelineViewportStateCreateInfo(
+    Pool* pool,
+    const VkPipelineViewportStateCreateInfo* from,
+    VkPipelineViewportStateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pViewports = nullptr;
+    if (from->pViewports)
+    {
+        to->pViewports = (VkViewport*)pool->alloc(from->viewportCount * sizeof(const VkViewport));
+        to->viewportCount = from->viewportCount;
+        for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
+        {
+            deepcopy_VkViewport(pool, from->pViewports + i, (VkViewport*)(to->pViewports + i));
+        }
+    }
+    to->pScissors = nullptr;
+    if (from->pScissors)
+    {
+        to->pScissors = (VkRect2D*)pool->alloc(from->scissorCount * sizeof(const VkRect2D));
+        to->scissorCount = from->scissorCount;
+        for (uint32_t i = 0; i < (uint32_t)from->scissorCount; ++i)
+        {
+            deepcopy_VkRect2D(pool, from->pScissors + i, (VkRect2D*)(to->pScissors + i));
+        }
+    }
+}
+
+void deepcopy_VkPipelineRasterizationStateCreateInfo(
+    Pool* pool,
+    const VkPipelineRasterizationStateCreateInfo* from,
+    VkPipelineRasterizationStateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineMultisampleStateCreateInfo(
+    Pool* pool,
+    const VkPipelineMultisampleStateCreateInfo* from,
+    VkPipelineMultisampleStateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pSampleMask = nullptr;
+    if (from->pSampleMask)
+    {
+        to->pSampleMask = (VkSampleMask*)pool->dupArray(from->pSampleMask, (((from->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+    }
+}
+
+void deepcopy_VkStencilOpState(
+    Pool* pool,
+    const VkStencilOpState* from,
+    VkStencilOpState* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPipelineDepthStencilStateCreateInfo(
+    Pool* pool,
+    const VkPipelineDepthStencilStateCreateInfo* from,
+    VkPipelineDepthStencilStateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkStencilOpState(pool, &from->front, (VkStencilOpState*)(&to->front));
+    deepcopy_VkStencilOpState(pool, &from->back, (VkStencilOpState*)(&to->back));
+}
+
+void deepcopy_VkPipelineColorBlendAttachmentState(
+    Pool* pool,
+    const VkPipelineColorBlendAttachmentState* from,
+    VkPipelineColorBlendAttachmentState* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPipelineColorBlendStateCreateInfo(
+    Pool* pool,
+    const VkPipelineColorBlendStateCreateInfo* from,
+    VkPipelineColorBlendStateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAttachments = nullptr;
+    if (from->pAttachments)
+    {
+        to->pAttachments = (VkPipelineColorBlendAttachmentState*)pool->alloc(from->attachmentCount * sizeof(const VkPipelineColorBlendAttachmentState));
+        to->attachmentCount = from->attachmentCount;
+        for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i)
+        {
+            deepcopy_VkPipelineColorBlendAttachmentState(pool, from->pAttachments + i, (VkPipelineColorBlendAttachmentState*)(to->pAttachments + i));
+        }
+    }
+    memcpy(to->blendConstants, from->blendConstants, 4 * sizeof(float));
+}
+
+void deepcopy_VkPipelineDynamicStateCreateInfo(
+    Pool* pool,
+    const VkPipelineDynamicStateCreateInfo* from,
+    VkPipelineDynamicStateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pDynamicStates = nullptr;
+    if (from->pDynamicStates)
+    {
+        to->pDynamicStates = (VkDynamicState*)pool->dupArray(from->pDynamicStates, from->dynamicStateCount * sizeof(const VkDynamicState));
+    }
+}
+
+void deepcopy_VkGraphicsPipelineCreateInfo(
+    Pool* pool,
+    const VkGraphicsPipelineCreateInfo* from,
+    VkGraphicsPipelineCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pStages = nullptr;
+    if (from->pStages)
+    {
+        to->pStages = (VkPipelineShaderStageCreateInfo*)pool->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+        to->stageCount = from->stageCount;
+        for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i)
+        {
+            deepcopy_VkPipelineShaderStageCreateInfo(pool, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
+        }
+    }
+    to->pVertexInputState = nullptr;
+    if (from->pVertexInputState)
+    {
+        to->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)pool->alloc(sizeof(const VkPipelineVertexInputStateCreateInfo));
+        deepcopy_VkPipelineVertexInputStateCreateInfo(pool, from->pVertexInputState, (VkPipelineVertexInputStateCreateInfo*)(to->pVertexInputState));
+    }
+    to->pInputAssemblyState = nullptr;
+    if (from->pInputAssemblyState)
+    {
+        to->pInputAssemblyState = (VkPipelineInputAssemblyStateCreateInfo*)pool->alloc(sizeof(const VkPipelineInputAssemblyStateCreateInfo));
+        deepcopy_VkPipelineInputAssemblyStateCreateInfo(pool, from->pInputAssemblyState, (VkPipelineInputAssemblyStateCreateInfo*)(to->pInputAssemblyState));
+    }
+    to->pTessellationState = nullptr;
+    if (from->pTessellationState)
+    {
+        to->pTessellationState = (VkPipelineTessellationStateCreateInfo*)pool->alloc(sizeof(const VkPipelineTessellationStateCreateInfo));
+        deepcopy_VkPipelineTessellationStateCreateInfo(pool, from->pTessellationState, (VkPipelineTessellationStateCreateInfo*)(to->pTessellationState));
+    }
+    to->pViewportState = nullptr;
+    if (from->pViewportState)
+    {
+        to->pViewportState = (VkPipelineViewportStateCreateInfo*)pool->alloc(sizeof(const VkPipelineViewportStateCreateInfo));
+        deepcopy_VkPipelineViewportStateCreateInfo(pool, from->pViewportState, (VkPipelineViewportStateCreateInfo*)(to->pViewportState));
+    }
+    to->pRasterizationState = nullptr;
+    if (from->pRasterizationState)
+    {
+        to->pRasterizationState = (VkPipelineRasterizationStateCreateInfo*)pool->alloc(sizeof(const VkPipelineRasterizationStateCreateInfo));
+        deepcopy_VkPipelineRasterizationStateCreateInfo(pool, from->pRasterizationState, (VkPipelineRasterizationStateCreateInfo*)(to->pRasterizationState));
+    }
+    to->pMultisampleState = nullptr;
+    if (from->pMultisampleState)
+    {
+        to->pMultisampleState = (VkPipelineMultisampleStateCreateInfo*)pool->alloc(sizeof(const VkPipelineMultisampleStateCreateInfo));
+        deepcopy_VkPipelineMultisampleStateCreateInfo(pool, from->pMultisampleState, (VkPipelineMultisampleStateCreateInfo*)(to->pMultisampleState));
+    }
+    to->pDepthStencilState = nullptr;
+    if (from->pDepthStencilState)
+    {
+        to->pDepthStencilState = (VkPipelineDepthStencilStateCreateInfo*)pool->alloc(sizeof(const VkPipelineDepthStencilStateCreateInfo));
+        deepcopy_VkPipelineDepthStencilStateCreateInfo(pool, from->pDepthStencilState, (VkPipelineDepthStencilStateCreateInfo*)(to->pDepthStencilState));
+    }
+    to->pColorBlendState = nullptr;
+    if (from->pColorBlendState)
+    {
+        to->pColorBlendState = (VkPipelineColorBlendStateCreateInfo*)pool->alloc(sizeof(const VkPipelineColorBlendStateCreateInfo));
+        deepcopy_VkPipelineColorBlendStateCreateInfo(pool, from->pColorBlendState, (VkPipelineColorBlendStateCreateInfo*)(to->pColorBlendState));
+    }
+    to->pDynamicState = nullptr;
+    if (from->pDynamicState)
+    {
+        to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)pool->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
+        deepcopy_VkPipelineDynamicStateCreateInfo(pool, from->pDynamicState, (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
+    }
+}
+
+void deepcopy_VkComputePipelineCreateInfo(
+    Pool* pool,
+    const VkComputePipelineCreateInfo* from,
+    VkComputePipelineCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkPipelineShaderStageCreateInfo(pool, &from->stage, (VkPipelineShaderStageCreateInfo*)(&to->stage));
+}
+
+void deepcopy_VkPushConstantRange(
+    Pool* pool,
+    const VkPushConstantRange* from,
+    VkPushConstantRange* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPipelineLayoutCreateInfo(
+    Pool* pool,
+    const VkPipelineLayoutCreateInfo* from,
+    VkPipelineLayoutCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pSetLayouts = nullptr;
+    if (from->pSetLayouts)
+    {
+        to->pSetLayouts = (VkDescriptorSetLayout*)pool->dupArray(from->pSetLayouts, from->setLayoutCount * sizeof(const VkDescriptorSetLayout));
+    }
+    to->pPushConstantRanges = nullptr;
+    if (from->pPushConstantRanges)
+    {
+        to->pPushConstantRanges = (VkPushConstantRange*)pool->alloc(from->pushConstantRangeCount * sizeof(const VkPushConstantRange));
+        to->pushConstantRangeCount = from->pushConstantRangeCount;
+        for (uint32_t i = 0; i < (uint32_t)from->pushConstantRangeCount; ++i)
+        {
+            deepcopy_VkPushConstantRange(pool, from->pPushConstantRanges + i, (VkPushConstantRange*)(to->pPushConstantRanges + i));
+        }
+    }
+}
+
+void deepcopy_VkSamplerCreateInfo(
+    Pool* pool,
+    const VkSamplerCreateInfo* from,
+    VkSamplerCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDescriptorSetLayoutBinding(
+    Pool* pool,
+    const VkDescriptorSetLayoutBinding* from,
+    VkDescriptorSetLayoutBinding* to)
+{
+    (void)pool;
+    *to = *from;
+    to->pImmutableSamplers = nullptr;
+    if (from->pImmutableSamplers)
+    {
+        to->pImmutableSamplers = (VkSampler*)pool->dupArray(from->pImmutableSamplers, from->descriptorCount * sizeof(const VkSampler));
+    }
+}
+
+void deepcopy_VkDescriptorSetLayoutCreateInfo(
+    Pool* pool,
+    const VkDescriptorSetLayoutCreateInfo* from,
+    VkDescriptorSetLayoutCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pBindings = nullptr;
+    if (from->pBindings)
+    {
+        to->pBindings = (VkDescriptorSetLayoutBinding*)pool->alloc(from->bindingCount * sizeof(const VkDescriptorSetLayoutBinding));
+        to->bindingCount = from->bindingCount;
+        for (uint32_t i = 0; i < (uint32_t)from->bindingCount; ++i)
+        {
+            deepcopy_VkDescriptorSetLayoutBinding(pool, from->pBindings + i, (VkDescriptorSetLayoutBinding*)(to->pBindings + i));
+        }
+    }
+}
+
+void deepcopy_VkDescriptorPoolSize(
+    Pool* pool,
+    const VkDescriptorPoolSize* from,
+    VkDescriptorPoolSize* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkDescriptorPoolCreateInfo(
+    Pool* pool,
+    const VkDescriptorPoolCreateInfo* from,
+    VkDescriptorPoolCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pPoolSizes = nullptr;
+    if (from->pPoolSizes)
+    {
+        to->pPoolSizes = (VkDescriptorPoolSize*)pool->alloc(from->poolSizeCount * sizeof(const VkDescriptorPoolSize));
+        to->poolSizeCount = from->poolSizeCount;
+        for (uint32_t i = 0; i < (uint32_t)from->poolSizeCount; ++i)
+        {
+            deepcopy_VkDescriptorPoolSize(pool, from->pPoolSizes + i, (VkDescriptorPoolSize*)(to->pPoolSizes + i));
+        }
+    }
+}
+
+void deepcopy_VkDescriptorSetAllocateInfo(
+    Pool* pool,
+    const VkDescriptorSetAllocateInfo* from,
+    VkDescriptorSetAllocateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pSetLayouts = nullptr;
+    if (from->pSetLayouts)
+    {
+        to->pSetLayouts = (VkDescriptorSetLayout*)pool->dupArray(from->pSetLayouts, from->descriptorSetCount * sizeof(const VkDescriptorSetLayout));
+    }
+}
+
+void deepcopy_VkDescriptorImageInfo(
+    Pool* pool,
+    const VkDescriptorImageInfo* from,
+    VkDescriptorImageInfo* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkDescriptorBufferInfo(
+    Pool* pool,
+    const VkDescriptorBufferInfo* from,
+    VkDescriptorBufferInfo* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkWriteDescriptorSet(
+    Pool* pool,
+    const VkWriteDescriptorSet* from,
+    VkWriteDescriptorSet* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pImageInfo = nullptr;
+    if (from->pImageInfo)
+    {
+        to->pImageInfo = (VkDescriptorImageInfo*)pool->alloc(from->descriptorCount * sizeof(const VkDescriptorImageInfo));
+        to->descriptorCount = from->descriptorCount;
+        for (uint32_t i = 0; i < (uint32_t)from->descriptorCount; ++i)
+        {
+            deepcopy_VkDescriptorImageInfo(pool, from->pImageInfo + i, (VkDescriptorImageInfo*)(to->pImageInfo + i));
+        }
+    }
+    to->pBufferInfo = nullptr;
+    if (from->pBufferInfo)
+    {
+        to->pBufferInfo = (VkDescriptorBufferInfo*)pool->alloc(from->descriptorCount * sizeof(const VkDescriptorBufferInfo));
+        to->descriptorCount = from->descriptorCount;
+        for (uint32_t i = 0; i < (uint32_t)from->descriptorCount; ++i)
+        {
+            deepcopy_VkDescriptorBufferInfo(pool, from->pBufferInfo + i, (VkDescriptorBufferInfo*)(to->pBufferInfo + i));
+        }
+    }
+    to->pTexelBufferView = nullptr;
+    if (from->pTexelBufferView)
+    {
+        to->pTexelBufferView = (VkBufferView*)pool->dupArray(from->pTexelBufferView, from->descriptorCount * sizeof(const VkBufferView));
+    }
+}
+
+void deepcopy_VkCopyDescriptorSet(
+    Pool* pool,
+    const VkCopyDescriptorSet* from,
+    VkCopyDescriptorSet* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkFramebufferCreateInfo(
+    Pool* pool,
+    const VkFramebufferCreateInfo* from,
+    VkFramebufferCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAttachments = nullptr;
+    if (from->pAttachments)
+    {
+        to->pAttachments = (VkImageView*)pool->dupArray(from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
+    }
+}
+
+void deepcopy_VkAttachmentDescription(
+    Pool* pool,
+    const VkAttachmentDescription* from,
+    VkAttachmentDescription* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkAttachmentReference(
+    Pool* pool,
+    const VkAttachmentReference* from,
+    VkAttachmentReference* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkSubpassDescription(
+    Pool* pool,
+    const VkSubpassDescription* from,
+    VkSubpassDescription* to)
+{
+    (void)pool;
+    *to = *from;
+    to->pInputAttachments = nullptr;
+    if (from->pInputAttachments)
+    {
+        to->pInputAttachments = (VkAttachmentReference*)pool->alloc(from->inputAttachmentCount * sizeof(const VkAttachmentReference));
+        to->inputAttachmentCount = from->inputAttachmentCount;
+        for (uint32_t i = 0; i < (uint32_t)from->inputAttachmentCount; ++i)
+        {
+            deepcopy_VkAttachmentReference(pool, from->pInputAttachments + i, (VkAttachmentReference*)(to->pInputAttachments + i));
+        }
+    }
+    to->pColorAttachments = nullptr;
+    if (from->pColorAttachments)
+    {
+        to->pColorAttachments = (VkAttachmentReference*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference));
+        to->colorAttachmentCount = from->colorAttachmentCount;
+        for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
+        {
+            deepcopy_VkAttachmentReference(pool, from->pColorAttachments + i, (VkAttachmentReference*)(to->pColorAttachments + i));
+        }
+    }
+    to->pResolveAttachments = nullptr;
+    if (from->pResolveAttachments)
+    {
+        to->pResolveAttachments = (VkAttachmentReference*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference));
+        to->colorAttachmentCount = from->colorAttachmentCount;
+        for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
+        {
+            deepcopy_VkAttachmentReference(pool, from->pResolveAttachments + i, (VkAttachmentReference*)(to->pResolveAttachments + i));
+        }
+    }
+    to->pDepthStencilAttachment = nullptr;
+    if (from->pDepthStencilAttachment)
+    {
+        to->pDepthStencilAttachment = (VkAttachmentReference*)pool->alloc(sizeof(const VkAttachmentReference));
+        deepcopy_VkAttachmentReference(pool, from->pDepthStencilAttachment, (VkAttachmentReference*)(to->pDepthStencilAttachment));
+    }
+    to->pPreserveAttachments = nullptr;
+    if (from->pPreserveAttachments)
+    {
+        to->pPreserveAttachments = (uint32_t*)pool->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkSubpassDependency(
+    Pool* pool,
+    const VkSubpassDependency* from,
+    VkSubpassDependency* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkRenderPassCreateInfo(
+    Pool* pool,
+    const VkRenderPassCreateInfo* from,
+    VkRenderPassCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAttachments = nullptr;
+    if (from->pAttachments)
+    {
+        to->pAttachments = (VkAttachmentDescription*)pool->alloc(from->attachmentCount * sizeof(const VkAttachmentDescription));
+        to->attachmentCount = from->attachmentCount;
+        for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i)
+        {
+            deepcopy_VkAttachmentDescription(pool, from->pAttachments + i, (VkAttachmentDescription*)(to->pAttachments + i));
+        }
+    }
+    to->pSubpasses = nullptr;
+    if (from->pSubpasses)
+    {
+        to->pSubpasses = (VkSubpassDescription*)pool->alloc(from->subpassCount * sizeof(const VkSubpassDescription));
+        to->subpassCount = from->subpassCount;
+        for (uint32_t i = 0; i < (uint32_t)from->subpassCount; ++i)
+        {
+            deepcopy_VkSubpassDescription(pool, from->pSubpasses + i, (VkSubpassDescription*)(to->pSubpasses + i));
+        }
+    }
+    to->pDependencies = nullptr;
+    if (from->pDependencies)
+    {
+        to->pDependencies = (VkSubpassDependency*)pool->alloc(from->dependencyCount * sizeof(const VkSubpassDependency));
+        to->dependencyCount = from->dependencyCount;
+        for (uint32_t i = 0; i < (uint32_t)from->dependencyCount; ++i)
+        {
+            deepcopy_VkSubpassDependency(pool, from->pDependencies + i, (VkSubpassDependency*)(to->pDependencies + i));
+        }
+    }
+}
+
+void deepcopy_VkCommandPoolCreateInfo(
+    Pool* pool,
+    const VkCommandPoolCreateInfo* from,
+    VkCommandPoolCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkCommandBufferAllocateInfo(
+    Pool* pool,
+    const VkCommandBufferAllocateInfo* from,
+    VkCommandBufferAllocateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkCommandBufferInheritanceInfo(
+    Pool* pool,
+    const VkCommandBufferInheritanceInfo* from,
+    VkCommandBufferInheritanceInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkCommandBufferBeginInfo(
+    Pool* pool,
+    const VkCommandBufferBeginInfo* from,
+    VkCommandBufferBeginInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pInheritanceInfo = nullptr;
+    if (from->pInheritanceInfo)
+    {
+        to->pInheritanceInfo = (VkCommandBufferInheritanceInfo*)pool->alloc(sizeof(const VkCommandBufferInheritanceInfo));
+        deepcopy_VkCommandBufferInheritanceInfo(pool, from->pInheritanceInfo, (VkCommandBufferInheritanceInfo*)(to->pInheritanceInfo));
+    }
+}
+
+void deepcopy_VkBufferCopy(
+    Pool* pool,
+    const VkBufferCopy* from,
+    VkBufferCopy* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkImageSubresourceLayers(
+    Pool* pool,
+    const VkImageSubresourceLayers* from,
+    VkImageSubresourceLayers* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkImageCopy(
+    Pool* pool,
+    const VkImageCopy* from,
+    VkImageCopy* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
+    deepcopy_VkOffset3D(pool, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
+    deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
+    deepcopy_VkOffset3D(pool, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
+    deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
+}
+
+void deepcopy_VkImageBlit(
+    Pool* pool,
+    const VkImageBlit* from,
+    VkImageBlit* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i)
+    {
+        deepcopy_VkOffset3D(pool, from->srcOffsets + i, (VkOffset3D*)(to->srcOffsets + i));
+    }
+    deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i)
+    {
+        deepcopy_VkOffset3D(pool, from->dstOffsets + i, (VkOffset3D*)(to->dstOffsets + i));
+    }
+}
+
+void deepcopy_VkBufferImageCopy(
+    Pool* pool,
+    const VkBufferImageCopy* from,
+    VkBufferImageCopy* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkImageSubresourceLayers(pool, &from->imageSubresource, (VkImageSubresourceLayers*)(&to->imageSubresource));
+    deepcopy_VkOffset3D(pool, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
+    deepcopy_VkExtent3D(pool, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
+}
+
+void deepcopy_VkClearColorValue(
+    Pool* pool,
+    const VkClearColorValue* from,
+    VkClearColorValue* to)
+{
+    (void)pool;
+    *to = *from;
+    memcpy(to->float32, from->float32, 4 * sizeof(float));
+    memcpy(to->int32, from->int32, 4 * sizeof(int32_t));
+    memcpy(to->uint32, from->uint32, 4 * sizeof(uint32_t));
+}
+
+void deepcopy_VkClearDepthStencilValue(
+    Pool* pool,
+    const VkClearDepthStencilValue* from,
+    VkClearDepthStencilValue* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkClearValue(
+    Pool* pool,
+    const VkClearValue* from,
+    VkClearValue* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkClearColorValue(pool, &from->color, (VkClearColorValue*)(&to->color));
+    deepcopy_VkClearDepthStencilValue(pool, &from->depthStencil, (VkClearDepthStencilValue*)(&to->depthStencil));
+}
+
+void deepcopy_VkClearAttachment(
+    Pool* pool,
+    const VkClearAttachment* from,
+    VkClearAttachment* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkClearValue(pool, &from->clearValue, (VkClearValue*)(&to->clearValue));
+}
+
+void deepcopy_VkClearRect(
+    Pool* pool,
+    const VkClearRect* from,
+    VkClearRect* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkRect2D(pool, &from->rect, (VkRect2D*)(&to->rect));
+}
+
+void deepcopy_VkImageResolve(
+    Pool* pool,
+    const VkImageResolve* from,
+    VkImageResolve* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
+    deepcopy_VkOffset3D(pool, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
+    deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
+    deepcopy_VkOffset3D(pool, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
+    deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
+}
+
+void deepcopy_VkMemoryBarrier(
+    Pool* pool,
+    const VkMemoryBarrier* from,
+    VkMemoryBarrier* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBufferMemoryBarrier(
+    Pool* pool,
+    const VkBufferMemoryBarrier* from,
+    VkBufferMemoryBarrier* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImageMemoryBarrier(
+    Pool* pool,
+    const VkImageMemoryBarrier* from,
+    VkImageMemoryBarrier* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkImageSubresourceRange(pool, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
+}
+
+void deepcopy_VkRenderPassBeginInfo(
+    Pool* pool,
+    const VkRenderPassBeginInfo* from,
+    VkRenderPassBeginInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkRect2D(pool, &from->renderArea, (VkRect2D*)(&to->renderArea));
+    to->pClearValues = nullptr;
+    if (from->pClearValues)
+    {
+        to->pClearValues = (VkClearValue*)pool->alloc(from->clearValueCount * sizeof(const VkClearValue));
+        to->clearValueCount = from->clearValueCount;
+        for (uint32_t i = 0; i < (uint32_t)from->clearValueCount; ++i)
+        {
+            deepcopy_VkClearValue(pool, from->pClearValues + i, (VkClearValue*)(to->pClearValues + i));
+        }
+    }
+}
+
+void deepcopy_VkDispatchIndirectCommand(
+    Pool* pool,
+    const VkDispatchIndirectCommand* from,
+    VkDispatchIndirectCommand* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkDrawIndexedIndirectCommand(
+    Pool* pool,
+    const VkDrawIndexedIndirectCommand* from,
+    VkDrawIndexedIndirectCommand* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkDrawIndirectCommand(
+    Pool* pool,
+    const VkDrawIndirectCommand* from,
+    VkDrawIndirectCommand* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkBaseOutStructure(
+    Pool* pool,
+    const VkBaseOutStructure* from,
+    VkBaseOutStructure* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (VkBaseOutStructure*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBaseInStructure(
+    Pool* pool,
+    const VkBaseInStructure* from,
+    VkBaseInStructure* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const VkBaseInStructure*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_VERSION_1_1
+void deepcopy_VkPhysicalDeviceSubgroupProperties(
+    Pool* pool,
+    const VkPhysicalDeviceSubgroupProperties* from,
+    VkPhysicalDeviceSubgroupProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBindBufferMemoryInfo(
+    Pool* pool,
+    const VkBindBufferMemoryInfo* from,
+    VkBindBufferMemoryInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBindImageMemoryInfo(
+    Pool* pool,
+    const VkBindImageMemoryInfo* from,
+    VkBindImageMemoryInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDevice16BitStorageFeatures(
+    Pool* pool,
+    const VkPhysicalDevice16BitStorageFeatures* from,
+    VkPhysicalDevice16BitStorageFeatures* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMemoryDedicatedRequirements(
+    Pool* pool,
+    const VkMemoryDedicatedRequirements* from,
+    VkMemoryDedicatedRequirements* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMemoryDedicatedAllocateInfo(
+    Pool* pool,
+    const VkMemoryDedicatedAllocateInfo* from,
+    VkMemoryDedicatedAllocateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMemoryAllocateFlagsInfo(
+    Pool* pool,
+    const VkMemoryAllocateFlagsInfo* from,
+    VkMemoryAllocateFlagsInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceGroupRenderPassBeginInfo(
+    Pool* pool,
+    const VkDeviceGroupRenderPassBeginInfo* from,
+    VkDeviceGroupRenderPassBeginInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pDeviceRenderAreas = nullptr;
+    if (from->pDeviceRenderAreas)
+    {
+        to->pDeviceRenderAreas = (VkRect2D*)pool->alloc(from->deviceRenderAreaCount * sizeof(const VkRect2D));
+        to->deviceRenderAreaCount = from->deviceRenderAreaCount;
+        for (uint32_t i = 0; i < (uint32_t)from->deviceRenderAreaCount; ++i)
+        {
+            deepcopy_VkRect2D(pool, from->pDeviceRenderAreas + i, (VkRect2D*)(to->pDeviceRenderAreas + i));
+        }
+    }
+}
+
+void deepcopy_VkDeviceGroupCommandBufferBeginInfo(
+    Pool* pool,
+    const VkDeviceGroupCommandBufferBeginInfo* from,
+    VkDeviceGroupCommandBufferBeginInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceGroupSubmitInfo(
+    Pool* pool,
+    const VkDeviceGroupSubmitInfo* from,
+    VkDeviceGroupSubmitInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pWaitSemaphoreDeviceIndices = nullptr;
+    if (from->pWaitSemaphoreDeviceIndices)
+    {
+        to->pWaitSemaphoreDeviceIndices = (uint32_t*)pool->dupArray(from->pWaitSemaphoreDeviceIndices, from->waitSemaphoreCount * sizeof(const uint32_t));
+    }
+    to->pCommandBufferDeviceMasks = nullptr;
+    if (from->pCommandBufferDeviceMasks)
+    {
+        to->pCommandBufferDeviceMasks = (uint32_t*)pool->dupArray(from->pCommandBufferDeviceMasks, from->commandBufferCount * sizeof(const uint32_t));
+    }
+    to->pSignalSemaphoreDeviceIndices = nullptr;
+    if (from->pSignalSemaphoreDeviceIndices)
+    {
+        to->pSignalSemaphoreDeviceIndices = (uint32_t*)pool->dupArray(from->pSignalSemaphoreDeviceIndices, from->signalSemaphoreCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkDeviceGroupBindSparseInfo(
+    Pool* pool,
+    const VkDeviceGroupBindSparseInfo* from,
+    VkDeviceGroupBindSparseInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBindBufferMemoryDeviceGroupInfo(
+    Pool* pool,
+    const VkBindBufferMemoryDeviceGroupInfo* from,
+    VkBindBufferMemoryDeviceGroupInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pDeviceIndices = nullptr;
+    if (from->pDeviceIndices)
+    {
+        to->pDeviceIndices = (uint32_t*)pool->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkBindImageMemoryDeviceGroupInfo(
+    Pool* pool,
+    const VkBindImageMemoryDeviceGroupInfo* from,
+    VkBindImageMemoryDeviceGroupInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pDeviceIndices = nullptr;
+    if (from->pDeviceIndices)
+    {
+        to->pDeviceIndices = (uint32_t*)pool->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
+    }
+    to->pSplitInstanceBindRegions = nullptr;
+    if (from->pSplitInstanceBindRegions)
+    {
+        to->pSplitInstanceBindRegions = (VkRect2D*)pool->alloc(from->splitInstanceBindRegionCount * sizeof(const VkRect2D));
+        to->splitInstanceBindRegionCount = from->splitInstanceBindRegionCount;
+        for (uint32_t i = 0; i < (uint32_t)from->splitInstanceBindRegionCount; ++i)
+        {
+            deepcopy_VkRect2D(pool, from->pSplitInstanceBindRegions + i, (VkRect2D*)(to->pSplitInstanceBindRegions + i));
+        }
+    }
+}
+
+void deepcopy_VkPhysicalDeviceGroupProperties(
+    Pool* pool,
+    const VkPhysicalDeviceGroupProperties* from,
+    VkPhysicalDeviceGroupProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    memcpy(to->physicalDevices, from->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
+}
+
+void deepcopy_VkDeviceGroupDeviceCreateInfo(
+    Pool* pool,
+    const VkDeviceGroupDeviceCreateInfo* from,
+    VkDeviceGroupDeviceCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pPhysicalDevices = nullptr;
+    if (from->pPhysicalDevices)
+    {
+        to->pPhysicalDevices = (VkPhysicalDevice*)pool->dupArray(from->pPhysicalDevices, from->physicalDeviceCount * sizeof(const VkPhysicalDevice));
+    }
+}
+
+void deepcopy_VkBufferMemoryRequirementsInfo2(
+    Pool* pool,
+    const VkBufferMemoryRequirementsInfo2* from,
+    VkBufferMemoryRequirementsInfo2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImageMemoryRequirementsInfo2(
+    Pool* pool,
+    const VkImageMemoryRequirementsInfo2* from,
+    VkImageMemoryRequirementsInfo2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImageSparseMemoryRequirementsInfo2(
+    Pool* pool,
+    const VkImageSparseMemoryRequirementsInfo2* from,
+    VkImageSparseMemoryRequirementsInfo2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMemoryRequirements2(
+    Pool* pool,
+    const VkMemoryRequirements2* from,
+    VkMemoryRequirements2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkMemoryRequirements(pool, &from->memoryRequirements, (VkMemoryRequirements*)(&to->memoryRequirements));
+}
+
+void deepcopy_VkSparseImageMemoryRequirements2(
+    Pool* pool,
+    const VkSparseImageMemoryRequirements2* from,
+    VkSparseImageMemoryRequirements2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkSparseImageMemoryRequirements(pool, &from->memoryRequirements, (VkSparseImageMemoryRequirements*)(&to->memoryRequirements));
+}
+
+void deepcopy_VkPhysicalDeviceFeatures2(
+    Pool* pool,
+    const VkPhysicalDeviceFeatures2* from,
+    VkPhysicalDeviceFeatures2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkPhysicalDeviceFeatures(pool, &from->features, (VkPhysicalDeviceFeatures*)(&to->features));
+}
+
+void deepcopy_VkPhysicalDeviceProperties2(
+    Pool* pool,
+    const VkPhysicalDeviceProperties2* from,
+    VkPhysicalDeviceProperties2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkPhysicalDeviceProperties(pool, &from->properties, (VkPhysicalDeviceProperties*)(&to->properties));
+}
+
+void deepcopy_VkFormatProperties2(
+    Pool* pool,
+    const VkFormatProperties2* from,
+    VkFormatProperties2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkFormatProperties(pool, &from->formatProperties, (VkFormatProperties*)(&to->formatProperties));
+}
+
+void deepcopy_VkImageFormatProperties2(
+    Pool* pool,
+    const VkImageFormatProperties2* from,
+    VkImageFormatProperties2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkImageFormatProperties(pool, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
+}
+
+void deepcopy_VkPhysicalDeviceImageFormatInfo2(
+    Pool* pool,
+    const VkPhysicalDeviceImageFormatInfo2* from,
+    VkPhysicalDeviceImageFormatInfo2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkQueueFamilyProperties2(
+    Pool* pool,
+    const VkQueueFamilyProperties2* from,
+    VkQueueFamilyProperties2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkQueueFamilyProperties(pool, &from->queueFamilyProperties, (VkQueueFamilyProperties*)(&to->queueFamilyProperties));
+}
+
+void deepcopy_VkPhysicalDeviceMemoryProperties2(
+    Pool* pool,
+    const VkPhysicalDeviceMemoryProperties2* from,
+    VkPhysicalDeviceMemoryProperties2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkPhysicalDeviceMemoryProperties(pool, &from->memoryProperties, (VkPhysicalDeviceMemoryProperties*)(&to->memoryProperties));
+}
+
+void deepcopy_VkSparseImageFormatProperties2(
+    Pool* pool,
+    const VkSparseImageFormatProperties2* from,
+    VkSparseImageFormatProperties2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkSparseImageFormatProperties(pool, &from->properties, (VkSparseImageFormatProperties*)(&to->properties));
+}
+
+void deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
+    Pool* pool,
+    const VkPhysicalDeviceSparseImageFormatInfo2* from,
+    VkPhysicalDeviceSparseImageFormatInfo2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDevicePointClippingProperties(
+    Pool* pool,
+    const VkPhysicalDevicePointClippingProperties* from,
+    VkPhysicalDevicePointClippingProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkInputAttachmentAspectReference(
+    Pool* pool,
+    const VkInputAttachmentAspectReference* from,
+    VkInputAttachmentAspectReference* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
+    Pool* pool,
+    const VkRenderPassInputAttachmentAspectCreateInfo* from,
+    VkRenderPassInputAttachmentAspectCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAspectReferences = nullptr;
+    if (from->pAspectReferences)
+    {
+        to->pAspectReferences = (VkInputAttachmentAspectReference*)pool->alloc(from->aspectReferenceCount * sizeof(const VkInputAttachmentAspectReference));
+        to->aspectReferenceCount = from->aspectReferenceCount;
+        for (uint32_t i = 0; i < (uint32_t)from->aspectReferenceCount; ++i)
+        {
+            deepcopy_VkInputAttachmentAspectReference(pool, from->pAspectReferences + i, (VkInputAttachmentAspectReference*)(to->pAspectReferences + i));
+        }
+    }
+}
+
+void deepcopy_VkImageViewUsageCreateInfo(
+    Pool* pool,
+    const VkImageViewUsageCreateInfo* from,
+    VkImageViewUsageCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
+    Pool* pool,
+    const VkPipelineTessellationDomainOriginStateCreateInfo* from,
+    VkPipelineTessellationDomainOriginStateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkRenderPassMultiviewCreateInfo(
+    Pool* pool,
+    const VkRenderPassMultiviewCreateInfo* from,
+    VkRenderPassMultiviewCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pViewMasks = nullptr;
+    if (from->pViewMasks)
+    {
+        to->pViewMasks = (uint32_t*)pool->dupArray(from->pViewMasks, from->subpassCount * sizeof(const uint32_t));
+    }
+    to->pViewOffsets = nullptr;
+    if (from->pViewOffsets)
+    {
+        to->pViewOffsets = (int32_t*)pool->dupArray(from->pViewOffsets, from->dependencyCount * sizeof(const int32_t));
+    }
+    to->pCorrelationMasks = nullptr;
+    if (from->pCorrelationMasks)
+    {
+        to->pCorrelationMasks = (uint32_t*)pool->dupArray(from->pCorrelationMasks, from->correlationMaskCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceMultiviewFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceMultiviewFeatures* from,
+    VkPhysicalDeviceMultiviewFeatures* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceMultiviewProperties(
+    Pool* pool,
+    const VkPhysicalDeviceMultiviewProperties* from,
+    VkPhysicalDeviceMultiviewProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceVariablePointerFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceVariablePointerFeatures* from,
+    VkPhysicalDeviceVariablePointerFeatures* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceProtectedMemoryFeatures* from,
+    VkPhysicalDeviceProtectedMemoryFeatures* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
+    Pool* pool,
+    const VkPhysicalDeviceProtectedMemoryProperties* from,
+    VkPhysicalDeviceProtectedMemoryProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceQueueInfo2(
+    Pool* pool,
+    const VkDeviceQueueInfo2* from,
+    VkDeviceQueueInfo2* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkProtectedSubmitInfo(
+    Pool* pool,
+    const VkProtectedSubmitInfo* from,
+    VkProtectedSubmitInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSamplerYcbcrConversionCreateInfo(
+    Pool* pool,
+    const VkSamplerYcbcrConversionCreateInfo* from,
+    VkSamplerYcbcrConversionCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkComponentMapping(pool, &from->components, (VkComponentMapping*)(&to->components));
+}
+
+void deepcopy_VkSamplerYcbcrConversionInfo(
+    Pool* pool,
+    const VkSamplerYcbcrConversionInfo* from,
+    VkSamplerYcbcrConversionInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBindImagePlaneMemoryInfo(
+    Pool* pool,
+    const VkBindImagePlaneMemoryInfo* from,
+    VkBindImagePlaneMemoryInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImagePlaneMemoryRequirementsInfo(
+    Pool* pool,
+    const VkImagePlaneMemoryRequirementsInfo* from,
+    VkImagePlaneMemoryRequirementsInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* from,
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
+    Pool* pool,
+    const VkSamplerYcbcrConversionImageFormatProperties* from,
+    VkSamplerYcbcrConversionImageFormatProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDescriptorUpdateTemplateEntry(
+    Pool* pool,
+    const VkDescriptorUpdateTemplateEntry* from,
+    VkDescriptorUpdateTemplateEntry* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkDescriptorUpdateTemplateCreateInfo(
+    Pool* pool,
+    const VkDescriptorUpdateTemplateCreateInfo* from,
+    VkDescriptorUpdateTemplateCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pDescriptorUpdateEntries = nullptr;
+    if (from->pDescriptorUpdateEntries)
+    {
+        to->pDescriptorUpdateEntries = (VkDescriptorUpdateTemplateEntry*)pool->alloc(from->descriptorUpdateEntryCount * sizeof(const VkDescriptorUpdateTemplateEntry));
+        to->descriptorUpdateEntryCount = from->descriptorUpdateEntryCount;
+        for (uint32_t i = 0; i < (uint32_t)from->descriptorUpdateEntryCount; ++i)
+        {
+            deepcopy_VkDescriptorUpdateTemplateEntry(pool, from->pDescriptorUpdateEntries + i, (VkDescriptorUpdateTemplateEntry*)(to->pDescriptorUpdateEntries + i));
+        }
+    }
+}
+
+void deepcopy_VkExternalMemoryProperties(
+    Pool* pool,
+    const VkExternalMemoryProperties* from,
+    VkExternalMemoryProperties* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
+    Pool* pool,
+    const VkPhysicalDeviceExternalImageFormatInfo* from,
+    VkPhysicalDeviceExternalImageFormatInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExternalImageFormatProperties(
+    Pool* pool,
+    const VkExternalImageFormatProperties* from,
+    VkExternalImageFormatProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExternalMemoryProperties(pool, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
+}
+
+void deepcopy_VkPhysicalDeviceExternalBufferInfo(
+    Pool* pool,
+    const VkPhysicalDeviceExternalBufferInfo* from,
+    VkPhysicalDeviceExternalBufferInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExternalBufferProperties(
+    Pool* pool,
+    const VkExternalBufferProperties* from,
+    VkExternalBufferProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExternalMemoryProperties(pool, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
+}
+
+void deepcopy_VkPhysicalDeviceIDProperties(
+    Pool* pool,
+    const VkPhysicalDeviceIDProperties* from,
+    VkPhysicalDeviceIDProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    memcpy(to->deviceUUID, from->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    memcpy(to->driverUUID, from->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    memcpy(to->deviceLUID, from->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
+}
+
+void deepcopy_VkExternalMemoryImageCreateInfo(
+    Pool* pool,
+    const VkExternalMemoryImageCreateInfo* from,
+    VkExternalMemoryImageCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExternalMemoryBufferCreateInfo(
+    Pool* pool,
+    const VkExternalMemoryBufferCreateInfo* from,
+    VkExternalMemoryBufferCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMemoryAllocateInfo(
+    Pool* pool,
+    const VkExportMemoryAllocateInfo* from,
+    VkExportMemoryAllocateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceExternalFenceInfo(
+    Pool* pool,
+    const VkPhysicalDeviceExternalFenceInfo* from,
+    VkPhysicalDeviceExternalFenceInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExternalFenceProperties(
+    Pool* pool,
+    const VkExternalFenceProperties* from,
+    VkExternalFenceProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportFenceCreateInfo(
+    Pool* pool,
+    const VkExportFenceCreateInfo* from,
+    VkExportFenceCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportSemaphoreCreateInfo(
+    Pool* pool,
+    const VkExportSemaphoreCreateInfo* from,
+    VkExportSemaphoreCreateInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
+    Pool* pool,
+    const VkPhysicalDeviceExternalSemaphoreInfo* from,
+    VkPhysicalDeviceExternalSemaphoreInfo* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExternalSemaphoreProperties(
+    Pool* pool,
+    const VkExternalSemaphoreProperties* from,
+    VkExternalSemaphoreProperties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceMaintenance3Properties(
+    Pool* pool,
+    const VkPhysicalDeviceMaintenance3Properties* from,
+    VkPhysicalDeviceMaintenance3Properties* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDescriptorSetLayoutSupport(
+    Pool* pool,
+    const VkDescriptorSetLayoutSupport* from,
+    VkDescriptorSetLayoutSupport* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceShaderDrawParameterFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceShaderDrawParameterFeatures* from,
+    VkPhysicalDeviceShaderDrawParameterFeatures* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_surface
+void deepcopy_VkSurfaceCapabilitiesKHR(
+    Pool* pool,
+    const VkSurfaceCapabilitiesKHR* from,
+    VkSurfaceCapabilitiesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkExtent2D(pool, &from->currentExtent, (VkExtent2D*)(&to->currentExtent));
+    deepcopy_VkExtent2D(pool, &from->minImageExtent, (VkExtent2D*)(&to->minImageExtent));
+    deepcopy_VkExtent2D(pool, &from->maxImageExtent, (VkExtent2D*)(&to->maxImageExtent));
+}
+
+void deepcopy_VkSurfaceFormatKHR(
+    Pool* pool,
+    const VkSurfaceFormatKHR* from,
+    VkSurfaceFormatKHR* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+#endif
+#ifdef VK_KHR_swapchain
+void deepcopy_VkSwapchainCreateInfoKHR(
+    Pool* pool,
+    const VkSwapchainCreateInfoKHR* from,
+    VkSwapchainCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent2D(pool, &from->imageExtent, (VkExtent2D*)(&to->imageExtent));
+    to->pQueueFamilyIndices = nullptr;
+    if (from->pQueueFamilyIndices)
+    {
+        to->pQueueFamilyIndices = (uint32_t*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkPresentInfoKHR(
+    Pool* pool,
+    const VkPresentInfoKHR* from,
+    VkPresentInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pWaitSemaphores = nullptr;
+    if (from->pWaitSemaphores)
+    {
+        to->pWaitSemaphores = (VkSemaphore*)pool->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
+    }
+    to->pSwapchains = nullptr;
+    if (from->pSwapchains)
+    {
+        to->pSwapchains = (VkSwapchainKHR*)pool->dupArray(from->pSwapchains, from->swapchainCount * sizeof(const VkSwapchainKHR));
+    }
+    to->pImageIndices = nullptr;
+    if (from->pImageIndices)
+    {
+        to->pImageIndices = (uint32_t*)pool->dupArray(from->pImageIndices, from->swapchainCount * sizeof(const uint32_t));
+    }
+    to->pResults = nullptr;
+    if (from->pResults)
+    {
+        to->pResults = (VkResult*)pool->dupArray(from->pResults, from->swapchainCount * sizeof(VkResult));
+    }
+}
+
+void deepcopy_VkImageSwapchainCreateInfoKHR(
+    Pool* pool,
+    const VkImageSwapchainCreateInfoKHR* from,
+    VkImageSwapchainCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBindImageMemorySwapchainInfoKHR(
+    Pool* pool,
+    const VkBindImageMemorySwapchainInfoKHR* from,
+    VkBindImageMemorySwapchainInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkAcquireNextImageInfoKHR(
+    Pool* pool,
+    const VkAcquireNextImageInfoKHR* from,
+    VkAcquireNextImageInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(
+    Pool* pool,
+    const VkDeviceGroupPresentCapabilitiesKHR* from,
+    VkDeviceGroupPresentCapabilitiesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    memcpy(to->presentMask, from->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
+}
+
+void deepcopy_VkDeviceGroupPresentInfoKHR(
+    Pool* pool,
+    const VkDeviceGroupPresentInfoKHR* from,
+    VkDeviceGroupPresentInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pDeviceMasks = nullptr;
+    if (from->pDeviceMasks)
+    {
+        to->pDeviceMasks = (uint32_t*)pool->dupArray(from->pDeviceMasks, from->swapchainCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(
+    Pool* pool,
+    const VkDeviceGroupSwapchainCreateInfoKHR* from,
+    VkDeviceGroupSwapchainCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_display
+void deepcopy_VkDisplayPropertiesKHR(
+    Pool* pool,
+    const VkDisplayPropertiesKHR* from,
+    VkDisplayPropertiesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    to->displayName = nullptr;
+    if (from->displayName)
+    {
+        to->displayName = pool->strDup(from->displayName);
+    }
+    deepcopy_VkExtent2D(pool, &from->physicalDimensions, (VkExtent2D*)(&to->physicalDimensions));
+    deepcopy_VkExtent2D(pool, &from->physicalResolution, (VkExtent2D*)(&to->physicalResolution));
+}
+
+void deepcopy_VkDisplayModeParametersKHR(
+    Pool* pool,
+    const VkDisplayModeParametersKHR* from,
+    VkDisplayModeParametersKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkExtent2D(pool, &from->visibleRegion, (VkExtent2D*)(&to->visibleRegion));
+}
+
+void deepcopy_VkDisplayModePropertiesKHR(
+    Pool* pool,
+    const VkDisplayModePropertiesKHR* from,
+    VkDisplayModePropertiesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkDisplayModeParametersKHR(pool, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
+}
+
+void deepcopy_VkDisplayModeCreateInfoKHR(
+    Pool* pool,
+    const VkDisplayModeCreateInfoKHR* from,
+    VkDisplayModeCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkDisplayModeParametersKHR(pool, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
+}
+
+void deepcopy_VkDisplayPlaneCapabilitiesKHR(
+    Pool* pool,
+    const VkDisplayPlaneCapabilitiesKHR* from,
+    VkDisplayPlaneCapabilitiesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkOffset2D(pool, &from->minSrcPosition, (VkOffset2D*)(&to->minSrcPosition));
+    deepcopy_VkOffset2D(pool, &from->maxSrcPosition, (VkOffset2D*)(&to->maxSrcPosition));
+    deepcopy_VkExtent2D(pool, &from->minSrcExtent, (VkExtent2D*)(&to->minSrcExtent));
+    deepcopy_VkExtent2D(pool, &from->maxSrcExtent, (VkExtent2D*)(&to->maxSrcExtent));
+    deepcopy_VkOffset2D(pool, &from->minDstPosition, (VkOffset2D*)(&to->minDstPosition));
+    deepcopy_VkOffset2D(pool, &from->maxDstPosition, (VkOffset2D*)(&to->maxDstPosition));
+    deepcopy_VkExtent2D(pool, &from->minDstExtent, (VkExtent2D*)(&to->minDstExtent));
+    deepcopy_VkExtent2D(pool, &from->maxDstExtent, (VkExtent2D*)(&to->maxDstExtent));
+}
+
+void deepcopy_VkDisplayPlanePropertiesKHR(
+    Pool* pool,
+    const VkDisplayPlanePropertiesKHR* from,
+    VkDisplayPlanePropertiesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkDisplaySurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkDisplaySurfaceCreateInfoKHR* from,
+    VkDisplaySurfaceCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent2D(pool, &from->imageExtent, (VkExtent2D*)(&to->imageExtent));
+}
+
+#endif
+#ifdef VK_KHR_display_swapchain
+void deepcopy_VkDisplayPresentInfoKHR(
+    Pool* pool,
+    const VkDisplayPresentInfoKHR* from,
+    VkDisplayPresentInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkRect2D(pool, &from->srcRect, (VkRect2D*)(&to->srcRect));
+    deepcopy_VkRect2D(pool, &from->dstRect, (VkRect2D*)(&to->dstRect));
+}
+
+#endif
+#ifdef VK_KHR_xlib_surface
+void deepcopy_VkXlibSurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkXlibSurfaceCreateInfoKHR* from,
+    VkXlibSurfaceCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->dpy = nullptr;
+    if (from->dpy)
+    {
+        to->dpy = (Display*)pool->dupArray(from->dpy, sizeof(Display));
+    }
+}
+
+#endif
+#ifdef VK_KHR_xcb_surface
+void deepcopy_VkXcbSurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkXcbSurfaceCreateInfoKHR* from,
+    VkXcbSurfaceCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->connection = nullptr;
+    if (from->connection)
+    {
+        to->connection = (xcb_connection_t*)pool->dupArray(from->connection, sizeof(xcb_connection_t));
+    }
+}
+
+#endif
+#ifdef VK_KHR_wayland_surface
+void deepcopy_VkWaylandSurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkWaylandSurfaceCreateInfoKHR* from,
+    VkWaylandSurfaceCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->display = nullptr;
+    if (from->display)
+    {
+        to->display = (wl_display*)pool->dupArray(from->display, sizeof(wl_display));
+    }
+    to->surface = nullptr;
+    if (from->surface)
+    {
+        to->surface = (wl_surface*)pool->dupArray(from->surface, sizeof(wl_surface));
+    }
+}
+
+#endif
+#ifdef VK_KHR_mir_surface
+void deepcopy_VkMirSurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkMirSurfaceCreateInfoKHR* from,
+    VkMirSurfaceCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->connection = nullptr;
+    if (from->connection)
+    {
+        to->connection = (MirConnection*)pool->dupArray(from->connection, sizeof(MirConnection));
+    }
+    to->mirSurface = nullptr;
+    if (from->mirSurface)
+    {
+        to->mirSurface = (MirSurface*)pool->dupArray(from->mirSurface, sizeof(MirSurface));
+    }
+}
+
+#endif
+#ifdef VK_KHR_android_surface
+void deepcopy_VkAndroidSurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkAndroidSurfaceCreateInfoKHR* from,
+    VkAndroidSurfaceCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->window = nullptr;
+    if (from->window)
+    {
+        to->window = (ANativeWindow*)pool->dupArray(from->window, sizeof(ANativeWindow));
+    }
+}
+
+#endif
+#ifdef VK_KHR_win32_surface
+void deepcopy_VkWin32SurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkWin32SurfaceCreateInfoKHR* from,
+    VkWin32SurfaceCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void deepcopy_VkImportMemoryWin32HandleInfoKHR(
+    Pool* pool,
+    const VkImportMemoryWin32HandleInfoKHR* from,
+    VkImportMemoryWin32HandleInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMemoryWin32HandleInfoKHR(
+    Pool* pool,
+    const VkExportMemoryWin32HandleInfoKHR* from,
+    VkExportMemoryWin32HandleInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAttributes = nullptr;
+    if (from->pAttributes)
+    {
+        to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+}
+
+void deepcopy_VkMemoryWin32HandlePropertiesKHR(
+    Pool* pool,
+    const VkMemoryWin32HandlePropertiesKHR* from,
+    VkMemoryWin32HandlePropertiesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMemoryGetWin32HandleInfoKHR(
+    Pool* pool,
+    const VkMemoryGetWin32HandleInfoKHR* from,
+    VkMemoryGetWin32HandleInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+void deepcopy_VkImportMemoryFdInfoKHR(
+    Pool* pool,
+    const VkImportMemoryFdInfoKHR* from,
+    VkImportMemoryFdInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMemoryFdPropertiesKHR(
+    Pool* pool,
+    const VkMemoryFdPropertiesKHR* from,
+    VkMemoryFdPropertiesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMemoryGetFdInfoKHR(
+    Pool* pool,
+    const VkMemoryGetFdInfoKHR* from,
+    VkMemoryGetFdInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+    Pool* pool,
+    const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
+    VkWin32KeyedMutexAcquireReleaseInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAcquireSyncs = nullptr;
+    if (from->pAcquireSyncs)
+    {
+        to->pAcquireSyncs = (VkDeviceMemory*)pool->dupArray(from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
+    }
+    to->pAcquireKeys = nullptr;
+    if (from->pAcquireKeys)
+    {
+        to->pAcquireKeys = (uint64_t*)pool->dupArray(from->pAcquireKeys, from->acquireCount * sizeof(const uint64_t));
+    }
+    to->pAcquireTimeouts = nullptr;
+    if (from->pAcquireTimeouts)
+    {
+        to->pAcquireTimeouts = (uint32_t*)pool->dupArray(from->pAcquireTimeouts, from->acquireCount * sizeof(const uint32_t));
+    }
+    to->pReleaseSyncs = nullptr;
+    if (from->pReleaseSyncs)
+    {
+        to->pReleaseSyncs = (VkDeviceMemory*)pool->dupArray(from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
+    }
+    to->pReleaseKeys = nullptr;
+    if (from->pReleaseKeys)
+    {
+        to->pReleaseKeys = (uint64_t*)pool->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
+    }
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(
+    Pool* pool,
+    const VkImportSemaphoreWin32HandleInfoKHR* from,
+    VkImportSemaphoreWin32HandleInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(
+    Pool* pool,
+    const VkExportSemaphoreWin32HandleInfoKHR* from,
+    VkExportSemaphoreWin32HandleInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAttributes = nullptr;
+    if (from->pAttributes)
+    {
+        to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+}
+
+void deepcopy_VkD3D12FenceSubmitInfoKHR(
+    Pool* pool,
+    const VkD3D12FenceSubmitInfoKHR* from,
+    VkD3D12FenceSubmitInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pWaitSemaphoreValues = nullptr;
+    if (from->pWaitSemaphoreValues)
+    {
+        to->pWaitSemaphoreValues = (uint64_t*)pool->dupArray(from->pWaitSemaphoreValues, from->waitSemaphoreValuesCount * sizeof(const uint64_t));
+    }
+    to->pSignalSemaphoreValues = nullptr;
+    if (from->pSignalSemaphoreValues)
+    {
+        to->pSignalSemaphoreValues = (uint64_t*)pool->dupArray(from->pSignalSemaphoreValues, from->signalSemaphoreValuesCount * sizeof(const uint64_t));
+    }
+}
+
+void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(
+    Pool* pool,
+    const VkSemaphoreGetWin32HandleInfoKHR* from,
+    VkSemaphoreGetWin32HandleInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void deepcopy_VkImportSemaphoreFdInfoKHR(
+    Pool* pool,
+    const VkImportSemaphoreFdInfoKHR* from,
+    VkImportSemaphoreFdInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSemaphoreGetFdInfoKHR(
+    Pool* pool,
+    const VkSemaphoreGetFdInfoKHR* from,
+    VkSemaphoreGetFdInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
+    Pool* pool,
+    const VkPhysicalDevicePushDescriptorPropertiesKHR* from,
+    VkPhysicalDevicePushDescriptorPropertiesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void deepcopy_VkRectLayerKHR(
+    Pool* pool,
+    const VkRectLayerKHR* from,
+    VkRectLayerKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkOffset2D(pool, &from->offset, (VkOffset2D*)(&to->offset));
+    deepcopy_VkExtent2D(pool, &from->extent, (VkExtent2D*)(&to->extent));
+}
+
+void deepcopy_VkPresentRegionKHR(
+    Pool* pool,
+    const VkPresentRegionKHR* from,
+    VkPresentRegionKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    to->pRectangles = nullptr;
+    if (from->pRectangles)
+    {
+        to->pRectangles = (VkRectLayerKHR*)pool->alloc(from->rectangleCount * sizeof(const VkRectLayerKHR));
+        to->rectangleCount = from->rectangleCount;
+        for (uint32_t i = 0; i < (uint32_t)from->rectangleCount; ++i)
+        {
+            deepcopy_VkRectLayerKHR(pool, from->pRectangles + i, (VkRectLayerKHR*)(to->pRectangles + i));
+        }
+    }
+}
+
+void deepcopy_VkPresentRegionsKHR(
+    Pool* pool,
+    const VkPresentRegionsKHR* from,
+    VkPresentRegionsKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pRegions = nullptr;
+    if (from->pRegions)
+    {
+        to->pRegions = (VkPresentRegionKHR*)pool->alloc(from->swapchainCount * sizeof(const VkPresentRegionKHR));
+        to->swapchainCount = from->swapchainCount;
+        for (uint32_t i = 0; i < (uint32_t)from->swapchainCount; ++i)
+        {
+            deepcopy_VkPresentRegionKHR(pool, from->pRegions + i, (VkPresentRegionKHR*)(to->pRegions + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+void deepcopy_VkAttachmentDescription2KHR(
+    Pool* pool,
+    const VkAttachmentDescription2KHR* from,
+    VkAttachmentDescription2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkAttachmentReference2KHR(
+    Pool* pool,
+    const VkAttachmentReference2KHR* from,
+    VkAttachmentReference2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSubpassDescription2KHR(
+    Pool* pool,
+    const VkSubpassDescription2KHR* from,
+    VkSubpassDescription2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pInputAttachments = nullptr;
+    if (from->pInputAttachments)
+    {
+        to->pInputAttachments = (VkAttachmentReference2KHR*)pool->alloc(from->inputAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+        to->inputAttachmentCount = from->inputAttachmentCount;
+        for (uint32_t i = 0; i < (uint32_t)from->inputAttachmentCount; ++i)
+        {
+            deepcopy_VkAttachmentReference2KHR(pool, from->pInputAttachments + i, (VkAttachmentReference2KHR*)(to->pInputAttachments + i));
+        }
+    }
+    to->pColorAttachments = nullptr;
+    if (from->pColorAttachments)
+    {
+        to->pColorAttachments = (VkAttachmentReference2KHR*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+        to->colorAttachmentCount = from->colorAttachmentCount;
+        for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
+        {
+            deepcopy_VkAttachmentReference2KHR(pool, from->pColorAttachments + i, (VkAttachmentReference2KHR*)(to->pColorAttachments + i));
+        }
+    }
+    to->pResolveAttachments = nullptr;
+    if (from->pResolveAttachments)
+    {
+        to->pResolveAttachments = (VkAttachmentReference2KHR*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+        to->colorAttachmentCount = from->colorAttachmentCount;
+        for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
+        {
+            deepcopy_VkAttachmentReference2KHR(pool, from->pResolveAttachments + i, (VkAttachmentReference2KHR*)(to->pResolveAttachments + i));
+        }
+    }
+    to->pDepthStencilAttachment = nullptr;
+    if (from->pDepthStencilAttachment)
+    {
+        to->pDepthStencilAttachment = (VkAttachmentReference2KHR*)pool->alloc(sizeof(const VkAttachmentReference2KHR));
+        deepcopy_VkAttachmentReference2KHR(pool, from->pDepthStencilAttachment, (VkAttachmentReference2KHR*)(to->pDepthStencilAttachment));
+    }
+    to->pPreserveAttachments = nullptr;
+    if (from->pPreserveAttachments)
+    {
+        to->pPreserveAttachments = (uint32_t*)pool->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkSubpassDependency2KHR(
+    Pool* pool,
+    const VkSubpassDependency2KHR* from,
+    VkSubpassDependency2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkRenderPassCreateInfo2KHR(
+    Pool* pool,
+    const VkRenderPassCreateInfo2KHR* from,
+    VkRenderPassCreateInfo2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAttachments = nullptr;
+    if (from->pAttachments)
+    {
+        to->pAttachments = (VkAttachmentDescription2KHR*)pool->alloc(from->attachmentCount * sizeof(const VkAttachmentDescription2KHR));
+        to->attachmentCount = from->attachmentCount;
+        for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i)
+        {
+            deepcopy_VkAttachmentDescription2KHR(pool, from->pAttachments + i, (VkAttachmentDescription2KHR*)(to->pAttachments + i));
+        }
+    }
+    to->pSubpasses = nullptr;
+    if (from->pSubpasses)
+    {
+        to->pSubpasses = (VkSubpassDescription2KHR*)pool->alloc(from->subpassCount * sizeof(const VkSubpassDescription2KHR));
+        to->subpassCount = from->subpassCount;
+        for (uint32_t i = 0; i < (uint32_t)from->subpassCount; ++i)
+        {
+            deepcopy_VkSubpassDescription2KHR(pool, from->pSubpasses + i, (VkSubpassDescription2KHR*)(to->pSubpasses + i));
+        }
+    }
+    to->pDependencies = nullptr;
+    if (from->pDependencies)
+    {
+        to->pDependencies = (VkSubpassDependency2KHR*)pool->alloc(from->dependencyCount * sizeof(const VkSubpassDependency2KHR));
+        to->dependencyCount = from->dependencyCount;
+        for (uint32_t i = 0; i < (uint32_t)from->dependencyCount; ++i)
+        {
+            deepcopy_VkSubpassDependency2KHR(pool, from->pDependencies + i, (VkSubpassDependency2KHR*)(to->pDependencies + i));
+        }
+    }
+    to->pCorrelatedViewMasks = nullptr;
+    if (from->pCorrelatedViewMasks)
+    {
+        to->pCorrelatedViewMasks = (uint32_t*)pool->dupArray(from->pCorrelatedViewMasks, from->correlatedViewMaskCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkSubpassBeginInfoKHR(
+    Pool* pool,
+    const VkSubpassBeginInfoKHR* from,
+    VkSubpassBeginInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSubpassEndInfoKHR(
+    Pool* pool,
+    const VkSubpassEndInfoKHR* from,
+    VkSubpassEndInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
+    Pool* pool,
+    const VkSharedPresentSurfaceCapabilitiesKHR* from,
+    VkSharedPresentSurfaceCapabilitiesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void deepcopy_VkImportFenceWin32HandleInfoKHR(
+    Pool* pool,
+    const VkImportFenceWin32HandleInfoKHR* from,
+    VkImportFenceWin32HandleInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportFenceWin32HandleInfoKHR(
+    Pool* pool,
+    const VkExportFenceWin32HandleInfoKHR* from,
+    VkExportFenceWin32HandleInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAttributes = nullptr;
+    if (from->pAttributes)
+    {
+        to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+}
+
+void deepcopy_VkFenceGetWin32HandleInfoKHR(
+    Pool* pool,
+    const VkFenceGetWin32HandleInfoKHR* from,
+    VkFenceGetWin32HandleInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+void deepcopy_VkImportFenceFdInfoKHR(
+    Pool* pool,
+    const VkImportFenceFdInfoKHR* from,
+    VkImportFenceFdInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkFenceGetFdInfoKHR(
+    Pool* pool,
+    const VkFenceGetFdInfoKHR* from,
+    VkFenceGetFdInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
+    Pool* pool,
+    const VkPhysicalDeviceSurfaceInfo2KHR* from,
+    VkPhysicalDeviceSurfaceInfo2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSurfaceCapabilities2KHR(
+    Pool* pool,
+    const VkSurfaceCapabilities2KHR* from,
+    VkSurfaceCapabilities2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkSurfaceCapabilitiesKHR(pool, &from->surfaceCapabilities, (VkSurfaceCapabilitiesKHR*)(&to->surfaceCapabilities));
+}
+
+void deepcopy_VkSurfaceFormat2KHR(
+    Pool* pool,
+    const VkSurfaceFormat2KHR* from,
+    VkSurfaceFormat2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkSurfaceFormatKHR(pool, &from->surfaceFormat, (VkSurfaceFormatKHR*)(&to->surfaceFormat));
+}
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void deepcopy_VkDisplayProperties2KHR(
+    Pool* pool,
+    const VkDisplayProperties2KHR* from,
+    VkDisplayProperties2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkDisplayPropertiesKHR(pool, &from->displayProperties, (VkDisplayPropertiesKHR*)(&to->displayProperties));
+}
+
+void deepcopy_VkDisplayPlaneProperties2KHR(
+    Pool* pool,
+    const VkDisplayPlaneProperties2KHR* from,
+    VkDisplayPlaneProperties2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkDisplayPlanePropertiesKHR(pool, &from->displayPlaneProperties, (VkDisplayPlanePropertiesKHR*)(&to->displayPlaneProperties));
+}
+
+void deepcopy_VkDisplayModeProperties2KHR(
+    Pool* pool,
+    const VkDisplayModeProperties2KHR* from,
+    VkDisplayModeProperties2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkDisplayModePropertiesKHR(pool, &from->displayModeProperties, (VkDisplayModePropertiesKHR*)(&to->displayModeProperties));
+}
+
+void deepcopy_VkDisplayPlaneInfo2KHR(
+    Pool* pool,
+    const VkDisplayPlaneInfo2KHR* from,
+    VkDisplayPlaneInfo2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDisplayPlaneCapabilities2KHR(
+    Pool* pool,
+    const VkDisplayPlaneCapabilities2KHR* from,
+    VkDisplayPlaneCapabilities2KHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkDisplayPlaneCapabilitiesKHR(pool, &from->capabilities, (VkDisplayPlaneCapabilitiesKHR*)(&to->capabilities));
+}
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+void deepcopy_VkImageFormatListCreateInfoKHR(
+    Pool* pool,
+    const VkImageFormatListCreateInfoKHR* from,
+    VkImageFormatListCreateInfoKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pViewFormats = nullptr;
+    if (from->pViewFormats)
+    {
+        to->pViewFormats = (VkFormat*)pool->dupArray(from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
+    }
+}
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+void deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR(
+    Pool* pool,
+    const VkPhysicalDevice8BitStorageFeaturesKHR* from,
+    VkPhysicalDevice8BitStorageFeaturesKHR* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void deepcopy_VkNativeBufferANDROID(
+    Pool* pool,
+    const VkNativeBufferANDROID* from,
+    VkNativeBufferANDROID* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->handle = nullptr;
+    if (from->handle)
+    {
+        to->handle = (uint32_t*)pool->dupArray(from->handle, sizeof(const uint32_t));
+    }
+}
+
+#endif
+#ifdef VK_EXT_debug_report
+void deepcopy_VkDebugReportCallbackCreateInfoEXT(
+    Pool* pool,
+    const VkDebugReportCallbackCreateInfoEXT* from,
+    VkDebugReportCallbackCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pUserData = nullptr;
+    if (from->pUserData)
+    {
+        to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
+    Pool* pool,
+    const VkPipelineRasterizationStateRasterizationOrderAMD* from,
+    VkPipelineRasterizationStateRasterizationOrderAMD* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void deepcopy_VkDebugMarkerObjectNameInfoEXT(
+    Pool* pool,
+    const VkDebugMarkerObjectNameInfoEXT* from,
+    VkDebugMarkerObjectNameInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pObjectName = nullptr;
+    if (from->pObjectName)
+    {
+        to->pObjectName = pool->strDup(from->pObjectName);
+    }
+}
+
+void deepcopy_VkDebugMarkerObjectTagInfoEXT(
+    Pool* pool,
+    const VkDebugMarkerObjectTagInfoEXT* from,
+    VkDebugMarkerObjectTagInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pTag = nullptr;
+    if (from->pTag)
+    {
+        to->pTag = (void*)pool->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
+    }
+}
+
+void deepcopy_VkDebugMarkerMarkerInfoEXT(
+    Pool* pool,
+    const VkDebugMarkerMarkerInfoEXT* from,
+    VkDebugMarkerMarkerInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pMarkerName = nullptr;
+    if (from->pMarkerName)
+    {
+        to->pMarkerName = pool->strDup(from->pMarkerName);
+    }
+    memcpy(to->color, from->color, 4 * sizeof(float));
+}
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void deepcopy_VkDedicatedAllocationImageCreateInfoNV(
+    Pool* pool,
+    const VkDedicatedAllocationImageCreateInfoNV* from,
+    VkDedicatedAllocationImageCreateInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
+    Pool* pool,
+    const VkDedicatedAllocationBufferCreateInfoNV* from,
+    VkDedicatedAllocationBufferCreateInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
+    Pool* pool,
+    const VkDedicatedAllocationMemoryAllocateInfoNV* from,
+    VkDedicatedAllocationMemoryAllocateInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void deepcopy_VkTextureLODGatherFormatPropertiesAMD(
+    Pool* pool,
+    const VkTextureLODGatherFormatPropertiesAMD* from,
+    VkTextureLODGatherFormatPropertiesAMD* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_shader_info
+void deepcopy_VkShaderResourceUsageAMD(
+    Pool* pool,
+    const VkShaderResourceUsageAMD* from,
+    VkShaderResourceUsageAMD* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkShaderStatisticsInfoAMD(
+    Pool* pool,
+    const VkShaderStatisticsInfoAMD* from,
+    VkShaderStatisticsInfoAMD* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkShaderResourceUsageAMD(pool, &from->resourceUsage, (VkShaderResourceUsageAMD*)(&to->resourceUsage));
+    memcpy(to->computeWorkGroupSize, from->computeWorkGroupSize, 3 * sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void deepcopy_VkExternalImageFormatPropertiesNV(
+    Pool* pool,
+    const VkExternalImageFormatPropertiesNV* from,
+    VkExternalImageFormatPropertiesNV* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkImageFormatProperties(pool, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
+}
+
+#endif
+#ifdef VK_NV_external_memory
+void deepcopy_VkExternalMemoryImageCreateInfoNV(
+    Pool* pool,
+    const VkExternalMemoryImageCreateInfoNV* from,
+    VkExternalMemoryImageCreateInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMemoryAllocateInfoNV(
+    Pool* pool,
+    const VkExportMemoryAllocateInfoNV* from,
+    VkExportMemoryAllocateInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void deepcopy_VkImportMemoryWin32HandleInfoNV(
+    Pool* pool,
+    const VkImportMemoryWin32HandleInfoNV* from,
+    VkImportMemoryWin32HandleInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMemoryWin32HandleInfoNV(
+    Pool* pool,
+    const VkExportMemoryWin32HandleInfoNV* from,
+    VkExportMemoryWin32HandleInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAttributes = nullptr;
+    if (from->pAttributes)
+    {
+        to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+}
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
+    Pool* pool,
+    const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
+    VkWin32KeyedMutexAcquireReleaseInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAcquireSyncs = nullptr;
+    if (from->pAcquireSyncs)
+    {
+        to->pAcquireSyncs = (VkDeviceMemory*)pool->dupArray(from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
+    }
+    to->pAcquireKeys = nullptr;
+    if (from->pAcquireKeys)
+    {
+        to->pAcquireKeys = (uint64_t*)pool->dupArray(from->pAcquireKeys, from->acquireCount * sizeof(const uint64_t));
+    }
+    to->pAcquireTimeoutMilliseconds = nullptr;
+    if (from->pAcquireTimeoutMilliseconds)
+    {
+        to->pAcquireTimeoutMilliseconds = (uint32_t*)pool->dupArray(from->pAcquireTimeoutMilliseconds, from->acquireCount * sizeof(const uint32_t));
+    }
+    to->pReleaseSyncs = nullptr;
+    if (from->pReleaseSyncs)
+    {
+        to->pReleaseSyncs = (VkDeviceMemory*)pool->dupArray(from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
+    }
+    to->pReleaseKeys = nullptr;
+    if (from->pReleaseKeys)
+    {
+        to->pReleaseKeys = (uint64_t*)pool->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
+    }
+}
+
+#endif
+#ifdef VK_EXT_validation_flags
+void deepcopy_VkValidationFlagsEXT(
+    Pool* pool,
+    const VkValidationFlagsEXT* from,
+    VkValidationFlagsEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pDisabledValidationChecks = nullptr;
+    if (from->pDisabledValidationChecks)
+    {
+        to->pDisabledValidationChecks = (VkValidationCheckEXT*)pool->dupArray(from->pDisabledValidationChecks, from->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+    }
+}
+
+#endif
+#ifdef VK_NN_vi_surface
+void deepcopy_VkViSurfaceCreateInfoNN(
+    Pool* pool,
+    const VkViSurfaceCreateInfoNN* from,
+    VkViSurfaceCreateInfoNN* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->window = nullptr;
+    if (from->window)
+    {
+        to->window = (void*)pool->dupArray(from->window, sizeof(uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void deepcopy_VkConditionalRenderingBeginInfoEXT(
+    Pool* pool,
+    const VkConditionalRenderingBeginInfoEXT* from,
+    VkConditionalRenderingBeginInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* from,
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+    Pool* pool,
+    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* from,
+    VkCommandBufferInheritanceConditionalRenderingInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void deepcopy_VkDeviceGeneratedCommandsFeaturesNVX(
+    Pool* pool,
+    const VkDeviceGeneratedCommandsFeaturesNVX* from,
+    VkDeviceGeneratedCommandsFeaturesNVX* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceGeneratedCommandsLimitsNVX(
+    Pool* pool,
+    const VkDeviceGeneratedCommandsLimitsNVX* from,
+    VkDeviceGeneratedCommandsLimitsNVX* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkIndirectCommandsTokenNVX(
+    Pool* pool,
+    const VkIndirectCommandsTokenNVX* from,
+    VkIndirectCommandsTokenNVX* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkIndirectCommandsLayoutTokenNVX(
+    Pool* pool,
+    const VkIndirectCommandsLayoutTokenNVX* from,
+    VkIndirectCommandsLayoutTokenNVX* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkIndirectCommandsLayoutCreateInfoNVX(
+    Pool* pool,
+    const VkIndirectCommandsLayoutCreateInfoNVX* from,
+    VkIndirectCommandsLayoutCreateInfoNVX* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pTokens = nullptr;
+    if (from->pTokens)
+    {
+        to->pTokens = (VkIndirectCommandsLayoutTokenNVX*)pool->alloc(from->tokenCount * sizeof(const VkIndirectCommandsLayoutTokenNVX));
+        to->tokenCount = from->tokenCount;
+        for (uint32_t i = 0; i < (uint32_t)from->tokenCount; ++i)
+        {
+            deepcopy_VkIndirectCommandsLayoutTokenNVX(pool, from->pTokens + i, (VkIndirectCommandsLayoutTokenNVX*)(to->pTokens + i));
+        }
+    }
+}
+
+void deepcopy_VkCmdProcessCommandsInfoNVX(
+    Pool* pool,
+    const VkCmdProcessCommandsInfoNVX* from,
+    VkCmdProcessCommandsInfoNVX* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pIndirectCommandsTokens = nullptr;
+    if (from->pIndirectCommandsTokens)
+    {
+        to->pIndirectCommandsTokens = (VkIndirectCommandsTokenNVX*)pool->alloc(from->indirectCommandsTokenCount * sizeof(const VkIndirectCommandsTokenNVX));
+        to->indirectCommandsTokenCount = from->indirectCommandsTokenCount;
+        for (uint32_t i = 0; i < (uint32_t)from->indirectCommandsTokenCount; ++i)
+        {
+            deepcopy_VkIndirectCommandsTokenNVX(pool, from->pIndirectCommandsTokens + i, (VkIndirectCommandsTokenNVX*)(to->pIndirectCommandsTokens + i));
+        }
+    }
+}
+
+void deepcopy_VkCmdReserveSpaceForCommandsInfoNVX(
+    Pool* pool,
+    const VkCmdReserveSpaceForCommandsInfoNVX* from,
+    VkCmdReserveSpaceForCommandsInfoNVX* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkObjectTableCreateInfoNVX(
+    Pool* pool,
+    const VkObjectTableCreateInfoNVX* from,
+    VkObjectTableCreateInfoNVX* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pObjectEntryTypes = nullptr;
+    if (from->pObjectEntryTypes)
+    {
+        to->pObjectEntryTypes = (VkObjectEntryTypeNVX*)pool->dupArray(from->pObjectEntryTypes, from->objectCount * sizeof(const VkObjectEntryTypeNVX));
+    }
+    to->pObjectEntryCounts = nullptr;
+    if (from->pObjectEntryCounts)
+    {
+        to->pObjectEntryCounts = (uint32_t*)pool->dupArray(from->pObjectEntryCounts, from->objectCount * sizeof(const uint32_t));
+    }
+    to->pObjectEntryUsageFlags = nullptr;
+    if (from->pObjectEntryUsageFlags)
+    {
+        to->pObjectEntryUsageFlags = (VkObjectEntryUsageFlagsNVX*)pool->dupArray(from->pObjectEntryUsageFlags, from->objectCount * sizeof(const VkObjectEntryUsageFlagsNVX));
+    }
+}
+
+void deepcopy_VkObjectTableEntryNVX(
+    Pool* pool,
+    const VkObjectTableEntryNVX* from,
+    VkObjectTableEntryNVX* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkObjectTablePipelineEntryNVX(
+    Pool* pool,
+    const VkObjectTablePipelineEntryNVX* from,
+    VkObjectTablePipelineEntryNVX* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkObjectTableDescriptorSetEntryNVX(
+    Pool* pool,
+    const VkObjectTableDescriptorSetEntryNVX* from,
+    VkObjectTableDescriptorSetEntryNVX* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkObjectTableVertexBufferEntryNVX(
+    Pool* pool,
+    const VkObjectTableVertexBufferEntryNVX* from,
+    VkObjectTableVertexBufferEntryNVX* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkObjectTableIndexBufferEntryNVX(
+    Pool* pool,
+    const VkObjectTableIndexBufferEntryNVX* from,
+    VkObjectTableIndexBufferEntryNVX* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkObjectTablePushConstantEntryNVX(
+    Pool* pool,
+    const VkObjectTablePushConstantEntryNVX* from,
+    VkObjectTablePushConstantEntryNVX* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void deepcopy_VkViewportWScalingNV(
+    Pool* pool,
+    const VkViewportWScalingNV* from,
+    VkViewportWScalingNV* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
+    Pool* pool,
+    const VkPipelineViewportWScalingStateCreateInfoNV* from,
+    VkPipelineViewportWScalingStateCreateInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pViewportWScalings = nullptr;
+    if (from->pViewportWScalings)
+    {
+        to->pViewportWScalings = (VkViewportWScalingNV*)pool->alloc(from->viewportCount * sizeof(const VkViewportWScalingNV));
+        to->viewportCount = from->viewportCount;
+        for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
+        {
+            deepcopy_VkViewportWScalingNV(pool, from->pViewportWScalings + i, (VkViewportWScalingNV*)(to->pViewportWScalings + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+void deepcopy_VkSurfaceCapabilities2EXT(
+    Pool* pool,
+    const VkSurfaceCapabilities2EXT* from,
+    VkSurfaceCapabilities2EXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent2D(pool, &from->currentExtent, (VkExtent2D*)(&to->currentExtent));
+    deepcopy_VkExtent2D(pool, &from->minImageExtent, (VkExtent2D*)(&to->minImageExtent));
+    deepcopy_VkExtent2D(pool, &from->maxImageExtent, (VkExtent2D*)(&to->maxImageExtent));
+}
+
+#endif
+#ifdef VK_EXT_display_control
+void deepcopy_VkDisplayPowerInfoEXT(
+    Pool* pool,
+    const VkDisplayPowerInfoEXT* from,
+    VkDisplayPowerInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceEventInfoEXT(
+    Pool* pool,
+    const VkDeviceEventInfoEXT* from,
+    VkDeviceEventInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDisplayEventInfoEXT(
+    Pool* pool,
+    const VkDisplayEventInfoEXT* from,
+    VkDisplayEventInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSwapchainCounterCreateInfoEXT(
+    Pool* pool,
+    const VkSwapchainCounterCreateInfoEXT* from,
+    VkSwapchainCounterCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+void deepcopy_VkRefreshCycleDurationGOOGLE(
+    Pool* pool,
+    const VkRefreshCycleDurationGOOGLE* from,
+    VkRefreshCycleDurationGOOGLE* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPastPresentationTimingGOOGLE(
+    Pool* pool,
+    const VkPastPresentationTimingGOOGLE* from,
+    VkPastPresentationTimingGOOGLE* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPresentTimeGOOGLE(
+    Pool* pool,
+    const VkPresentTimeGOOGLE* from,
+    VkPresentTimeGOOGLE* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPresentTimesInfoGOOGLE(
+    Pool* pool,
+    const VkPresentTimesInfoGOOGLE* from,
+    VkPresentTimesInfoGOOGLE* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pTimes = nullptr;
+    if (from->pTimes)
+    {
+        to->pTimes = (VkPresentTimeGOOGLE*)pool->alloc(from->swapchainCount * sizeof(const VkPresentTimeGOOGLE));
+        to->swapchainCount = from->swapchainCount;
+        for (uint32_t i = 0; i < (uint32_t)from->swapchainCount; ++i)
+        {
+            deepcopy_VkPresentTimeGOOGLE(pool, from->pTimes + i, (VkPresentTimeGOOGLE*)(to->pTimes + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    Pool* pool,
+    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* from,
+    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void deepcopy_VkViewportSwizzleNV(
+    Pool* pool,
+    const VkViewportSwizzleNV* from,
+    VkViewportSwizzleNV* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
+    Pool* pool,
+    const VkPipelineViewportSwizzleStateCreateInfoNV* from,
+    VkPipelineViewportSwizzleStateCreateInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pViewportSwizzles = nullptr;
+    if (from->pViewportSwizzles)
+    {
+        to->pViewportSwizzles = (VkViewportSwizzleNV*)pool->alloc(from->viewportCount * sizeof(const VkViewportSwizzleNV));
+        to->viewportCount = from->viewportCount;
+        for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
+        {
+            deepcopy_VkViewportSwizzleNV(pool, from->pViewportSwizzles + i, (VkViewportSwizzleNV*)(to->pViewportSwizzles + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* from,
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
+    Pool* pool,
+    const VkPipelineDiscardRectangleStateCreateInfoEXT* from,
+    VkPipelineDiscardRectangleStateCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pDiscardRectangles = nullptr;
+    if (from->pDiscardRectangles)
+    {
+        to->pDiscardRectangles = (VkRect2D*)pool->alloc(from->discardRectangleCount * sizeof(const VkRect2D));
+        to->discardRectangleCount = from->discardRectangleCount;
+        for (uint32_t i = 0; i < (uint32_t)from->discardRectangleCount; ++i)
+        {
+            deepcopy_VkRect2D(pool, from->pDiscardRectangles + i, (VkRect2D*)(to->pDiscardRectangles + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* from,
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+    Pool* pool,
+    const VkPipelineRasterizationConservativeStateCreateInfoEXT* from,
+    VkPipelineRasterizationConservativeStateCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void deepcopy_VkXYColorEXT(
+    Pool* pool,
+    const VkXYColorEXT* from,
+    VkXYColorEXT* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkHdrMetadataEXT(
+    Pool* pool,
+    const VkHdrMetadataEXT* from,
+    VkHdrMetadataEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkXYColorEXT(pool, &from->displayPrimaryRed, (VkXYColorEXT*)(&to->displayPrimaryRed));
+    deepcopy_VkXYColorEXT(pool, &from->displayPrimaryGreen, (VkXYColorEXT*)(&to->displayPrimaryGreen));
+    deepcopy_VkXYColorEXT(pool, &from->displayPrimaryBlue, (VkXYColorEXT*)(&to->displayPrimaryBlue));
+    deepcopy_VkXYColorEXT(pool, &from->whitePoint, (VkXYColorEXT*)(&to->whitePoint));
+}
+
+#endif
+#ifdef VK_MVK_ios_surface
+void deepcopy_VkIOSSurfaceCreateInfoMVK(
+    Pool* pool,
+    const VkIOSSurfaceCreateInfoMVK* from,
+    VkIOSSurfaceCreateInfoMVK* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pView = nullptr;
+    if (from->pView)
+    {
+        to->pView = (void*)pool->dupArray(from->pView, sizeof(const uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_MVK_macos_surface
+void deepcopy_VkMacOSSurfaceCreateInfoMVK(
+    Pool* pool,
+    const VkMacOSSurfaceCreateInfoMVK* from,
+    VkMacOSSurfaceCreateInfoMVK* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pView = nullptr;
+    if (from->pView)
+    {
+        to->pView = (void*)pool->dupArray(from->pView, sizeof(const uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void deepcopy_VkDebugUtilsObjectNameInfoEXT(
+    Pool* pool,
+    const VkDebugUtilsObjectNameInfoEXT* from,
+    VkDebugUtilsObjectNameInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pObjectName = nullptr;
+    if (from->pObjectName)
+    {
+        to->pObjectName = pool->strDup(from->pObjectName);
+    }
+}
+
+void deepcopy_VkDebugUtilsObjectTagInfoEXT(
+    Pool* pool,
+    const VkDebugUtilsObjectTagInfoEXT* from,
+    VkDebugUtilsObjectTagInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pTag = nullptr;
+    if (from->pTag)
+    {
+        to->pTag = (void*)pool->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
+    }
+}
+
+void deepcopy_VkDebugUtilsLabelEXT(
+    Pool* pool,
+    const VkDebugUtilsLabelEXT* from,
+    VkDebugUtilsLabelEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pLabelName = nullptr;
+    if (from->pLabelName)
+    {
+        to->pLabelName = pool->strDup(from->pLabelName);
+    }
+    memcpy(to->color, from->color, 4 * sizeof(float));
+}
+
+void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(
+    Pool* pool,
+    const VkDebugUtilsMessengerCallbackDataEXT* from,
+    VkDebugUtilsMessengerCallbackDataEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pMessageIdName = nullptr;
+    if (from->pMessageIdName)
+    {
+        to->pMessageIdName = pool->strDup(from->pMessageIdName);
+    }
+    to->pMessage = nullptr;
+    if (from->pMessage)
+    {
+        to->pMessage = pool->strDup(from->pMessage);
+    }
+    to->pQueueLabels = nullptr;
+    if (from->pQueueLabels)
+    {
+        to->pQueueLabels = (VkDebugUtilsLabelEXT*)pool->alloc(from->queueLabelCount * sizeof(VkDebugUtilsLabelEXT));
+        to->queueLabelCount = from->queueLabelCount;
+        for (uint32_t i = 0; i < (uint32_t)from->queueLabelCount; ++i)
+        {
+            deepcopy_VkDebugUtilsLabelEXT(pool, from->pQueueLabels + i, (VkDebugUtilsLabelEXT*)(to->pQueueLabels + i));
+        }
+    }
+    to->pCmdBufLabels = nullptr;
+    if (from->pCmdBufLabels)
+    {
+        to->pCmdBufLabels = (VkDebugUtilsLabelEXT*)pool->alloc(from->cmdBufLabelCount * sizeof(VkDebugUtilsLabelEXT));
+        to->cmdBufLabelCount = from->cmdBufLabelCount;
+        for (uint32_t i = 0; i < (uint32_t)from->cmdBufLabelCount; ++i)
+        {
+            deepcopy_VkDebugUtilsLabelEXT(pool, from->pCmdBufLabels + i, (VkDebugUtilsLabelEXT*)(to->pCmdBufLabels + i));
+        }
+    }
+    to->pObjects = nullptr;
+    if (from->pObjects)
+    {
+        to->pObjects = (VkDebugUtilsObjectNameInfoEXT*)pool->alloc(from->objectCount * sizeof(VkDebugUtilsObjectNameInfoEXT));
+        to->objectCount = from->objectCount;
+        for (uint32_t i = 0; i < (uint32_t)from->objectCount; ++i)
+        {
+            deepcopy_VkDebugUtilsObjectNameInfoEXT(pool, from->pObjects + i, (VkDebugUtilsObjectNameInfoEXT*)(to->pObjects + i));
+        }
+    }
+}
+
+void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
+    Pool* pool,
+    const VkDebugUtilsMessengerCreateInfoEXT* from,
+    VkDebugUtilsMessengerCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pUserData = nullptr;
+    if (from->pUserData)
+    {
+        to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void deepcopy_VkAndroidHardwareBufferUsageANDROID(
+    Pool* pool,
+    const VkAndroidHardwareBufferUsageANDROID* from,
+    VkAndroidHardwareBufferUsageANDROID* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkAndroidHardwareBufferPropertiesANDROID(
+    Pool* pool,
+    const VkAndroidHardwareBufferPropertiesANDROID* from,
+    VkAndroidHardwareBufferPropertiesANDROID* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
+    Pool* pool,
+    const VkAndroidHardwareBufferFormatPropertiesANDROID* from,
+    VkAndroidHardwareBufferFormatPropertiesANDROID* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkComponentMapping(pool, &from->samplerYcbcrConversionComponents, (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
+}
+
+void deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
+    Pool* pool,
+    const VkImportAndroidHardwareBufferInfoANDROID* from,
+    VkImportAndroidHardwareBufferInfoANDROID* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->buffer = nullptr;
+    if (from->buffer)
+    {
+        to->buffer = (AHardwareBuffer*)pool->dupArray(from->buffer, sizeof(AHardwareBuffer));
+    }
+}
+
+void deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+    Pool* pool,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* from,
+    VkMemoryGetAndroidHardwareBufferInfoANDROID* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExternalFormatANDROID(
+    Pool* pool,
+    const VkExternalFormatANDROID* from,
+    VkExternalFormatANDROID* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void deepcopy_VkSamplerReductionModeCreateInfoEXT(
+    Pool* pool,
+    const VkSamplerReductionModeCreateInfoEXT* from,
+    VkSamplerReductionModeCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* from,
+    VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void deepcopy_VkSampleLocationEXT(
+    Pool* pool,
+    const VkSampleLocationEXT* from,
+    VkSampleLocationEXT* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkSampleLocationsInfoEXT(
+    Pool* pool,
+    const VkSampleLocationsInfoEXT* from,
+    VkSampleLocationsInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent2D(pool, &from->sampleLocationGridSize, (VkExtent2D*)(&to->sampleLocationGridSize));
+    to->pSampleLocations = nullptr;
+    if (from->pSampleLocations)
+    {
+        to->pSampleLocations = (VkSampleLocationEXT*)pool->alloc(from->sampleLocationsCount * sizeof(const VkSampleLocationEXT));
+        to->sampleLocationsCount = from->sampleLocationsCount;
+        for (uint32_t i = 0; i < (uint32_t)from->sampleLocationsCount; ++i)
+        {
+            deepcopy_VkSampleLocationEXT(pool, from->pSampleLocations + i, (VkSampleLocationEXT*)(to->pSampleLocations + i));
+        }
+    }
+}
+
+void deepcopy_VkAttachmentSampleLocationsEXT(
+    Pool* pool,
+    const VkAttachmentSampleLocationsEXT* from,
+    VkAttachmentSampleLocationsEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+}
+
+void deepcopy_VkSubpassSampleLocationsEXT(
+    Pool* pool,
+    const VkSubpassSampleLocationsEXT* from,
+    VkSubpassSampleLocationsEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+}
+
+void deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
+    Pool* pool,
+    const VkRenderPassSampleLocationsBeginInfoEXT* from,
+    VkRenderPassSampleLocationsBeginInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pAttachmentInitialSampleLocations = nullptr;
+    if (from->pAttachmentInitialSampleLocations)
+    {
+        to->pAttachmentInitialSampleLocations = (VkAttachmentSampleLocationsEXT*)pool->alloc(from->attachmentInitialSampleLocationsCount * sizeof(const VkAttachmentSampleLocationsEXT));
+        to->attachmentInitialSampleLocationsCount = from->attachmentInitialSampleLocationsCount;
+        for (uint32_t i = 0; i < (uint32_t)from->attachmentInitialSampleLocationsCount; ++i)
+        {
+            deepcopy_VkAttachmentSampleLocationsEXT(pool, from->pAttachmentInitialSampleLocations + i, (VkAttachmentSampleLocationsEXT*)(to->pAttachmentInitialSampleLocations + i));
+        }
+    }
+    to->pPostSubpassSampleLocations = nullptr;
+    if (from->pPostSubpassSampleLocations)
+    {
+        to->pPostSubpassSampleLocations = (VkSubpassSampleLocationsEXT*)pool->alloc(from->postSubpassSampleLocationsCount * sizeof(const VkSubpassSampleLocationsEXT));
+        to->postSubpassSampleLocationsCount = from->postSubpassSampleLocationsCount;
+        for (uint32_t i = 0; i < (uint32_t)from->postSubpassSampleLocationsCount; ++i)
+        {
+            deepcopy_VkSubpassSampleLocationsEXT(pool, from->pPostSubpassSampleLocations + i, (VkSubpassSampleLocationsEXT*)(to->pPostSubpassSampleLocations + i));
+        }
+    }
+}
+
+void deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
+    Pool* pool,
+    const VkPipelineSampleLocationsStateCreateInfoEXT* from,
+    VkPipelineSampleLocationsStateCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+}
+
+void deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceSampleLocationsPropertiesEXT* from,
+    VkPhysicalDeviceSampleLocationsPropertiesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent2D(pool, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
+    memcpy(to->sampleLocationCoordinateRange, from->sampleLocationCoordinateRange, 2 * sizeof(float));
+}
+
+void deepcopy_VkMultisamplePropertiesEXT(
+    Pool* pool,
+    const VkMultisamplePropertiesEXT* from,
+    VkMultisamplePropertiesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent2D(pool, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
+}
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* from,
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* from,
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+    Pool* pool,
+    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* from,
+    VkPipelineColorBlendAdvancedStateCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
+    Pool* pool,
+    const VkPipelineCoverageToColorStateCreateInfoNV* from,
+    VkPipelineCoverageToColorStateCreateInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
+    Pool* pool,
+    const VkPipelineCoverageModulationStateCreateInfoNV* from,
+    VkPipelineCoverageModulationStateCreateInfoNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pCoverageModulationTable = nullptr;
+    if (from->pCoverageModulationTable)
+    {
+        to->pCoverageModulationTable = (float*)pool->dupArray(from->pCoverageModulationTable, from->coverageModulationTableCount * sizeof(const float));
+    }
+}
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void deepcopy_VkValidationCacheCreateInfoEXT(
+    Pool* pool,
+    const VkValidationCacheCreateInfoEXT* from,
+    VkValidationCacheCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pInitialData = nullptr;
+    if (from->pInitialData)
+    {
+        to->pInitialData = (void*)pool->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
+    }
+}
+
+void deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
+    Pool* pool,
+    const VkShaderModuleValidationCacheCreateInfoEXT* from,
+    VkShaderModuleValidationCacheCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+    Pool* pool,
+    const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* from,
+    VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pBindingFlags = nullptr;
+    if (from->pBindingFlags)
+    {
+        to->pBindingFlags = (VkDescriptorBindingFlagsEXT*)pool->dupArray(from->pBindingFlags, from->bindingCount * sizeof(const VkDescriptorBindingFlagsEXT));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* from,
+    VkPhysicalDeviceDescriptorIndexingFeaturesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* from,
+    VkPhysicalDeviceDescriptorIndexingPropertiesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+    Pool* pool,
+    const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* from,
+    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pDescriptorCounts = nullptr;
+    if (from->pDescriptorCounts)
+    {
+        to->pDescriptorCounts = (uint32_t*)pool->dupArray(from->pDescriptorCounts, from->descriptorSetCount * sizeof(const uint32_t));
+    }
+}
+
+void deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+    Pool* pool,
+    const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* from,
+    VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+    Pool* pool,
+    const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
+    VkDeviceQueueGlobalPriorityCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void deepcopy_VkImportMemoryHostPointerInfoEXT(
+    Pool* pool,
+    const VkImportMemoryHostPointerInfoEXT* from,
+    VkImportMemoryHostPointerInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pHostPointer = nullptr;
+    if (from->pHostPointer)
+    {
+        to->pHostPointer = (void*)pool->dupArray(from->pHostPointer, sizeof(uint8_t));
+    }
+}
+
+void deepcopy_VkMemoryHostPointerPropertiesEXT(
+    Pool* pool,
+    const VkMemoryHostPointerPropertiesEXT* from,
+    VkMemoryHostPointerPropertiesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
+    Pool* pool,
+    const VkPhysicalDeviceShaderCorePropertiesAMD* from,
+    VkPhysicalDeviceShaderCorePropertiesAMD* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
+    Pool* pool,
+    const VkVertexInputBindingDivisorDescriptionEXT* from,
+    VkVertexInputBindingDivisorDescriptionEXT* to)
+{
+    (void)pool;
+    *to = *from;
+}
+
+void deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+    Pool* pool,
+    const VkPipelineVertexInputDivisorStateCreateInfoEXT* from,
+    VkPipelineVertexInputDivisorStateCreateInfoEXT* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (const void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pVertexBindingDivisors = nullptr;
+    if (from->pVertexBindingDivisors)
+    {
+        to->pVertexBindingDivisors = (VkVertexInputBindingDivisorDescriptionEXT*)pool->alloc(from->vertexBindingDivisorCount * sizeof(const VkVertexInputBindingDivisorDescriptionEXT));
+        to->vertexBindingDivisorCount = from->vertexBindingDivisorCount;
+        for (uint32_t i = 0; i < (uint32_t)from->vertexBindingDivisorCount; ++i)
+        {
+            deepcopy_VkVertexInputBindingDivisorDescriptionEXT(pool, from->pVertexBindingDivisors + i, (VkVertexInputBindingDivisorDescriptionEXT*)(to->pVertexBindingDivisors + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void deepcopy_VkQueueFamilyCheckpointPropertiesNV(
+    Pool* pool,
+    const VkQueueFamilyCheckpointPropertiesNV* from,
+    VkQueueFamilyCheckpointPropertiesNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkCheckpointDataNV(
+    Pool* pool,
+    const VkCheckpointDataNV* from,
+    VkCheckpointDataNV* to)
+{
+    (void)pool;
+    *to = *from;
+    size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+    to->pNext = nullptr;
+    if (pNext_size)
+    {
+        to->pNext = (void*)pool->alloc(pNext_size);
+        deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+    }
+    to->pCheckpointMarker = nullptr;
+    if (from->pCheckpointMarker)
+    {
+        to->pCheckpointMarker = (void*)pool->dupArray(from->pCheckpointMarker, sizeof(uint8_t));
+    }
+}
+
+#endif
+void deepcopy_extension_struct(
+    Pool* pool,
+    const void* structExtension,
+    void* structExtension_out)
+{
+    if (!structExtension)
+    {
+        return;
+    }
+    uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
+    switch(structType)
+    {
+#ifdef VK_VERSION_1_1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+        {
+            deepcopy_VkPhysicalDeviceSubgroupProperties(pool, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+        {
+            deepcopy_VkPhysicalDevice16BitStorageFeatures(pool, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+        {
+            deepcopy_VkMemoryDedicatedRequirements(pool, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+        {
+            deepcopy_VkMemoryDedicatedAllocateInfo(pool, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+        {
+            deepcopy_VkMemoryAllocateFlagsInfo(pool, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+        {
+            deepcopy_VkDeviceGroupRenderPassBeginInfo(pool, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+        {
+            deepcopy_VkDeviceGroupCommandBufferBeginInfo(pool, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+        {
+            deepcopy_VkDeviceGroupSubmitInfo(pool, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+        {
+            deepcopy_VkDeviceGroupBindSparseInfo(pool, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+        {
+            deepcopy_VkBindBufferMemoryDeviceGroupInfo(pool, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+        {
+            deepcopy_VkBindImageMemoryDeviceGroupInfo(pool, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+        {
+            deepcopy_VkDeviceGroupDeviceCreateInfo(pool, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+        {
+            deepcopy_VkPhysicalDeviceFeatures2(pool, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+        {
+            deepcopy_VkPhysicalDevicePointClippingProperties(pool, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension), reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+        {
+            deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(pool, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension), reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+        {
+            deepcopy_VkImageViewUsageCreateInfo(pool, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+        {
+            deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(pool, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension), reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+        {
+            deepcopy_VkRenderPassMultiviewCreateInfo(pool, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+        {
+            deepcopy_VkPhysicalDeviceMultiviewFeatures(pool, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+        {
+            deepcopy_VkPhysicalDeviceMultiviewProperties(pool, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
+        {
+            deepcopy_VkPhysicalDeviceVariablePointerFeatures(pool, reinterpret_cast<const VkPhysicalDeviceVariablePointerFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+        {
+            deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(pool, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+        {
+            deepcopy_VkPhysicalDeviceProtectedMemoryProperties(pool, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+        {
+            deepcopy_VkProtectedSubmitInfo(pool, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+        {
+            deepcopy_VkSamplerYcbcrConversionInfo(pool, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+        {
+            deepcopy_VkBindImagePlaneMemoryInfo(pool, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+        {
+            deepcopy_VkImagePlaneMemoryRequirementsInfo(pool, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+        {
+            deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(pool, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+        {
+            deepcopy_VkSamplerYcbcrConversionImageFormatProperties(pool, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension), reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+        {
+            deepcopy_VkPhysicalDeviceExternalImageFormatInfo(pool, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension), reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+        {
+            deepcopy_VkExternalImageFormatProperties(pool, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+        {
+            deepcopy_VkPhysicalDeviceIDProperties(pool, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+        {
+            deepcopy_VkExternalMemoryImageCreateInfo(pool, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+        {
+            deepcopy_VkExternalMemoryBufferCreateInfo(pool, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+        {
+            deepcopy_VkExportMemoryAllocateInfo(pool, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+        {
+            deepcopy_VkExportFenceCreateInfo(pool, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+        {
+            deepcopy_VkExportSemaphoreCreateInfo(pool, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+        {
+            deepcopy_VkPhysicalDeviceMaintenance3Properties(pool, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension), reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
+        {
+            deepcopy_VkPhysicalDeviceShaderDrawParameterFeatures(pool, reinterpret_cast<const VkPhysicalDeviceShaderDrawParameterFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_swapchain
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+        {
+            deepcopy_VkImageSwapchainCreateInfoKHR(pool, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+        {
+            deepcopy_VkBindImageMemorySwapchainInfoKHR(pool, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+        {
+            deepcopy_VkDeviceGroupPresentInfoKHR(pool, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+        {
+            deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(pool, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension), reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_display_swapchain
+        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+        {
+            deepcopy_VkDisplayPresentInfoKHR(pool, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_memory_win32
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            deepcopy_VkImportMemoryWin32HandleInfoKHR(pool, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            deepcopy_VkExportMemoryWin32HandleInfoKHR(pool, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_memory_fd
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+        {
+            deepcopy_VkImportMemoryFdInfoKHR(pool, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension), reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+        {
+            deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(pool, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension), reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+        {
+            deepcopy_VkExportSemaphoreWin32HandleInfoKHR(pool, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+        {
+            deepcopy_VkD3D12FenceSubmitInfoKHR(pool, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension), reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_push_descriptor
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+        {
+            deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(pool, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_incremental_present
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+        {
+            deepcopy_VkPresentRegionsKHR(pool, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension), reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+        {
+            deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(pool, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension), reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_fence_win32
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+        {
+            deepcopy_VkExportFenceWin32HandleInfoKHR(pool, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_image_format_list
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+        {
+            deepcopy_VkImageFormatListCreateInfoKHR(pool, reinterpret_cast<const VkImageFormatListCreateInfoKHR*>(structExtension), reinterpret_cast<VkImageFormatListCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_8bit_storage
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+        {
+            deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ANDROID_native_buffer
+        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
+        {
+            deepcopy_VkNativeBufferANDROID(pool, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension), reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_debug_report
+        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+        {
+            deepcopy_VkDebugReportCallbackCreateInfoEXT(pool, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension), reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_rasterization_order
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+        {
+            deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(pool, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension), reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_dedicated_allocation
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+        {
+            deepcopy_VkDedicatedAllocationImageCreateInfoNV(pool, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+        {
+            deepcopy_VkDedicatedAllocationBufferCreateInfoNV(pool, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+        {
+            deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(pool, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+        {
+            deepcopy_VkTextureLODGatherFormatPropertiesAMD(pool, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension), reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_external_memory
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+        {
+            deepcopy_VkExternalMemoryImageCreateInfoNV(pool, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+        {
+            deepcopy_VkExportMemoryAllocateInfoNV(pool, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension), reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_external_memory_win32
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+        {
+            deepcopy_VkImportMemoryWin32HandleInfoNV(pool, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+        {
+            deepcopy_VkExportMemoryWin32HandleInfoNV(pool, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension), reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+        {
+            deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(pool, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension), reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_validation_flags
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+        {
+            deepcopy_VkValidationFlagsEXT(pool, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension), reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_conditional_rendering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+        {
+            deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(pool, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension), reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+        {
+            deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_display_control
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+        {
+            deepcopy_VkSwapchainCounterCreateInfoEXT(pool, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension), reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_GOOGLE_display_timing
+        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+        {
+            deepcopy_VkPresentTimesInfoGOOGLE(pool, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension), reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+        {
+            deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(pool, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_viewport_swizzle
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+        {
+            deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_discard_rectangles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+        {
+            deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_conservative_rasterization
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+        {
+            deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+        {
+            deepcopy_VkDebugUtilsMessengerCreateInfoEXT(pool, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension), reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+        {
+            deepcopy_VkAndroidHardwareBufferUsageANDROID(pool, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+        {
+            deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(pool, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension), reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+        {
+            deepcopy_VkImportAndroidHardwareBufferInfoANDROID(pool, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+        {
+            deepcopy_VkExternalFormatANDROID(pool, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+        {
+            deepcopy_VkSamplerReductionModeCreateInfoEXT(pool, reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(structExtension), reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_sample_locations
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+        {
+            deepcopy_VkSampleLocationsInfoEXT(pool, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension), reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+        {
+            deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(pool, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension), reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+        {
+            deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+        {
+            deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+        {
+            deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+        {
+            deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(pool, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_validation_cache
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+        {
+            deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(pool, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension), reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_indexing
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+        {
+            deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(pool, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension), reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+        {
+            deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(pool, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension), reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+        {
+            deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(pool, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(structExtension), reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
+        {
+            deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(pool, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension), reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_external_memory_host
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+        {
+            deepcopy_VkImportMemoryHostPointerInfoEXT(pool, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension), reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+        {
+            deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(pool, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+        {
+            deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+        {
+            deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(pool, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+        {
+            deepcopy_VkQueueFamilyCheckpointPropertiesNV(pool, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension), reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+            break;
+        }
+#endif
+        default:
+        {
+            return;
+        }
+    }
+}
+
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
new file mode 100644
index 0000000..07828f5
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -0,0 +1,2012 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_deepcopy_guest
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "vk_platform_compat.h"
+
+#include "goldfish_vk_private_defs.h"
+#include "android/base/Pool.h"
+using android::base::Pool;
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+void deepcopy_VkApplicationInfo(
+    Pool* pool,
+    const VkApplicationInfo* from,
+    VkApplicationInfo* to);
+
+void deepcopy_VkInstanceCreateInfo(
+    Pool* pool,
+    const VkInstanceCreateInfo* from,
+    VkInstanceCreateInfo* to);
+
+void deepcopy_VkAllocationCallbacks(
+    Pool* pool,
+    const VkAllocationCallbacks* from,
+    VkAllocationCallbacks* to);
+
+void deepcopy_VkPhysicalDeviceFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceFeatures* from,
+    VkPhysicalDeviceFeatures* to);
+
+void deepcopy_VkFormatProperties(
+    Pool* pool,
+    const VkFormatProperties* from,
+    VkFormatProperties* to);
+
+void deepcopy_VkExtent3D(
+    Pool* pool,
+    const VkExtent3D* from,
+    VkExtent3D* to);
+
+void deepcopy_VkImageFormatProperties(
+    Pool* pool,
+    const VkImageFormatProperties* from,
+    VkImageFormatProperties* to);
+
+void deepcopy_VkPhysicalDeviceLimits(
+    Pool* pool,
+    const VkPhysicalDeviceLimits* from,
+    VkPhysicalDeviceLimits* to);
+
+void deepcopy_VkPhysicalDeviceSparseProperties(
+    Pool* pool,
+    const VkPhysicalDeviceSparseProperties* from,
+    VkPhysicalDeviceSparseProperties* to);
+
+void deepcopy_VkPhysicalDeviceProperties(
+    Pool* pool,
+    const VkPhysicalDeviceProperties* from,
+    VkPhysicalDeviceProperties* to);
+
+void deepcopy_VkQueueFamilyProperties(
+    Pool* pool,
+    const VkQueueFamilyProperties* from,
+    VkQueueFamilyProperties* to);
+
+void deepcopy_VkMemoryType(
+    Pool* pool,
+    const VkMemoryType* from,
+    VkMemoryType* to);
+
+void deepcopy_VkMemoryHeap(
+    Pool* pool,
+    const VkMemoryHeap* from,
+    VkMemoryHeap* to);
+
+void deepcopy_VkPhysicalDeviceMemoryProperties(
+    Pool* pool,
+    const VkPhysicalDeviceMemoryProperties* from,
+    VkPhysicalDeviceMemoryProperties* to);
+
+void deepcopy_VkDeviceQueueCreateInfo(
+    Pool* pool,
+    const VkDeviceQueueCreateInfo* from,
+    VkDeviceQueueCreateInfo* to);
+
+void deepcopy_VkDeviceCreateInfo(
+    Pool* pool,
+    const VkDeviceCreateInfo* from,
+    VkDeviceCreateInfo* to);
+
+void deepcopy_VkExtensionProperties(
+    Pool* pool,
+    const VkExtensionProperties* from,
+    VkExtensionProperties* to);
+
+void deepcopy_VkLayerProperties(
+    Pool* pool,
+    const VkLayerProperties* from,
+    VkLayerProperties* to);
+
+void deepcopy_VkSubmitInfo(
+    Pool* pool,
+    const VkSubmitInfo* from,
+    VkSubmitInfo* to);
+
+void deepcopy_VkMemoryAllocateInfo(
+    Pool* pool,
+    const VkMemoryAllocateInfo* from,
+    VkMemoryAllocateInfo* to);
+
+void deepcopy_VkMappedMemoryRange(
+    Pool* pool,
+    const VkMappedMemoryRange* from,
+    VkMappedMemoryRange* to);
+
+void deepcopy_VkMemoryRequirements(
+    Pool* pool,
+    const VkMemoryRequirements* from,
+    VkMemoryRequirements* to);
+
+void deepcopy_VkSparseImageFormatProperties(
+    Pool* pool,
+    const VkSparseImageFormatProperties* from,
+    VkSparseImageFormatProperties* to);
+
+void deepcopy_VkSparseImageMemoryRequirements(
+    Pool* pool,
+    const VkSparseImageMemoryRequirements* from,
+    VkSparseImageMemoryRequirements* to);
+
+void deepcopy_VkSparseMemoryBind(
+    Pool* pool,
+    const VkSparseMemoryBind* from,
+    VkSparseMemoryBind* to);
+
+void deepcopy_VkSparseBufferMemoryBindInfo(
+    Pool* pool,
+    const VkSparseBufferMemoryBindInfo* from,
+    VkSparseBufferMemoryBindInfo* to);
+
+void deepcopy_VkSparseImageOpaqueMemoryBindInfo(
+    Pool* pool,
+    const VkSparseImageOpaqueMemoryBindInfo* from,
+    VkSparseImageOpaqueMemoryBindInfo* to);
+
+void deepcopy_VkImageSubresource(
+    Pool* pool,
+    const VkImageSubresource* from,
+    VkImageSubresource* to);
+
+void deepcopy_VkOffset3D(
+    Pool* pool,
+    const VkOffset3D* from,
+    VkOffset3D* to);
+
+void deepcopy_VkSparseImageMemoryBind(
+    Pool* pool,
+    const VkSparseImageMemoryBind* from,
+    VkSparseImageMemoryBind* to);
+
+void deepcopy_VkSparseImageMemoryBindInfo(
+    Pool* pool,
+    const VkSparseImageMemoryBindInfo* from,
+    VkSparseImageMemoryBindInfo* to);
+
+void deepcopy_VkBindSparseInfo(
+    Pool* pool,
+    const VkBindSparseInfo* from,
+    VkBindSparseInfo* to);
+
+void deepcopy_VkFenceCreateInfo(
+    Pool* pool,
+    const VkFenceCreateInfo* from,
+    VkFenceCreateInfo* to);
+
+void deepcopy_VkSemaphoreCreateInfo(
+    Pool* pool,
+    const VkSemaphoreCreateInfo* from,
+    VkSemaphoreCreateInfo* to);
+
+void deepcopy_VkEventCreateInfo(
+    Pool* pool,
+    const VkEventCreateInfo* from,
+    VkEventCreateInfo* to);
+
+void deepcopy_VkQueryPoolCreateInfo(
+    Pool* pool,
+    const VkQueryPoolCreateInfo* from,
+    VkQueryPoolCreateInfo* to);
+
+void deepcopy_VkBufferCreateInfo(
+    Pool* pool,
+    const VkBufferCreateInfo* from,
+    VkBufferCreateInfo* to);
+
+void deepcopy_VkBufferViewCreateInfo(
+    Pool* pool,
+    const VkBufferViewCreateInfo* from,
+    VkBufferViewCreateInfo* to);
+
+void deepcopy_VkImageCreateInfo(
+    Pool* pool,
+    const VkImageCreateInfo* from,
+    VkImageCreateInfo* to);
+
+void deepcopy_VkSubresourceLayout(
+    Pool* pool,
+    const VkSubresourceLayout* from,
+    VkSubresourceLayout* to);
+
+void deepcopy_VkComponentMapping(
+    Pool* pool,
+    const VkComponentMapping* from,
+    VkComponentMapping* to);
+
+void deepcopy_VkImageSubresourceRange(
+    Pool* pool,
+    const VkImageSubresourceRange* from,
+    VkImageSubresourceRange* to);
+
+void deepcopy_VkImageViewCreateInfo(
+    Pool* pool,
+    const VkImageViewCreateInfo* from,
+    VkImageViewCreateInfo* to);
+
+void deepcopy_VkShaderModuleCreateInfo(
+    Pool* pool,
+    const VkShaderModuleCreateInfo* from,
+    VkShaderModuleCreateInfo* to);
+
+void deepcopy_VkPipelineCacheCreateInfo(
+    Pool* pool,
+    const VkPipelineCacheCreateInfo* from,
+    VkPipelineCacheCreateInfo* to);
+
+void deepcopy_VkSpecializationMapEntry(
+    Pool* pool,
+    const VkSpecializationMapEntry* from,
+    VkSpecializationMapEntry* to);
+
+void deepcopy_VkSpecializationInfo(
+    Pool* pool,
+    const VkSpecializationInfo* from,
+    VkSpecializationInfo* to);
+
+void deepcopy_VkPipelineShaderStageCreateInfo(
+    Pool* pool,
+    const VkPipelineShaderStageCreateInfo* from,
+    VkPipelineShaderStageCreateInfo* to);
+
+void deepcopy_VkVertexInputBindingDescription(
+    Pool* pool,
+    const VkVertexInputBindingDescription* from,
+    VkVertexInputBindingDescription* to);
+
+void deepcopy_VkVertexInputAttributeDescription(
+    Pool* pool,
+    const VkVertexInputAttributeDescription* from,
+    VkVertexInputAttributeDescription* to);
+
+void deepcopy_VkPipelineVertexInputStateCreateInfo(
+    Pool* pool,
+    const VkPipelineVertexInputStateCreateInfo* from,
+    VkPipelineVertexInputStateCreateInfo* to);
+
+void deepcopy_VkPipelineInputAssemblyStateCreateInfo(
+    Pool* pool,
+    const VkPipelineInputAssemblyStateCreateInfo* from,
+    VkPipelineInputAssemblyStateCreateInfo* to);
+
+void deepcopy_VkPipelineTessellationStateCreateInfo(
+    Pool* pool,
+    const VkPipelineTessellationStateCreateInfo* from,
+    VkPipelineTessellationStateCreateInfo* to);
+
+void deepcopy_VkViewport(
+    Pool* pool,
+    const VkViewport* from,
+    VkViewport* to);
+
+void deepcopy_VkOffset2D(
+    Pool* pool,
+    const VkOffset2D* from,
+    VkOffset2D* to);
+
+void deepcopy_VkExtent2D(
+    Pool* pool,
+    const VkExtent2D* from,
+    VkExtent2D* to);
+
+void deepcopy_VkRect2D(
+    Pool* pool,
+    const VkRect2D* from,
+    VkRect2D* to);
+
+void deepcopy_VkPipelineViewportStateCreateInfo(
+    Pool* pool,
+    const VkPipelineViewportStateCreateInfo* from,
+    VkPipelineViewportStateCreateInfo* to);
+
+void deepcopy_VkPipelineRasterizationStateCreateInfo(
+    Pool* pool,
+    const VkPipelineRasterizationStateCreateInfo* from,
+    VkPipelineRasterizationStateCreateInfo* to);
+
+void deepcopy_VkPipelineMultisampleStateCreateInfo(
+    Pool* pool,
+    const VkPipelineMultisampleStateCreateInfo* from,
+    VkPipelineMultisampleStateCreateInfo* to);
+
+void deepcopy_VkStencilOpState(
+    Pool* pool,
+    const VkStencilOpState* from,
+    VkStencilOpState* to);
+
+void deepcopy_VkPipelineDepthStencilStateCreateInfo(
+    Pool* pool,
+    const VkPipelineDepthStencilStateCreateInfo* from,
+    VkPipelineDepthStencilStateCreateInfo* to);
+
+void deepcopy_VkPipelineColorBlendAttachmentState(
+    Pool* pool,
+    const VkPipelineColorBlendAttachmentState* from,
+    VkPipelineColorBlendAttachmentState* to);
+
+void deepcopy_VkPipelineColorBlendStateCreateInfo(
+    Pool* pool,
+    const VkPipelineColorBlendStateCreateInfo* from,
+    VkPipelineColorBlendStateCreateInfo* to);
+
+void deepcopy_VkPipelineDynamicStateCreateInfo(
+    Pool* pool,
+    const VkPipelineDynamicStateCreateInfo* from,
+    VkPipelineDynamicStateCreateInfo* to);
+
+void deepcopy_VkGraphicsPipelineCreateInfo(
+    Pool* pool,
+    const VkGraphicsPipelineCreateInfo* from,
+    VkGraphicsPipelineCreateInfo* to);
+
+void deepcopy_VkComputePipelineCreateInfo(
+    Pool* pool,
+    const VkComputePipelineCreateInfo* from,
+    VkComputePipelineCreateInfo* to);
+
+void deepcopy_VkPushConstantRange(
+    Pool* pool,
+    const VkPushConstantRange* from,
+    VkPushConstantRange* to);
+
+void deepcopy_VkPipelineLayoutCreateInfo(
+    Pool* pool,
+    const VkPipelineLayoutCreateInfo* from,
+    VkPipelineLayoutCreateInfo* to);
+
+void deepcopy_VkSamplerCreateInfo(
+    Pool* pool,
+    const VkSamplerCreateInfo* from,
+    VkSamplerCreateInfo* to);
+
+void deepcopy_VkDescriptorSetLayoutBinding(
+    Pool* pool,
+    const VkDescriptorSetLayoutBinding* from,
+    VkDescriptorSetLayoutBinding* to);
+
+void deepcopy_VkDescriptorSetLayoutCreateInfo(
+    Pool* pool,
+    const VkDescriptorSetLayoutCreateInfo* from,
+    VkDescriptorSetLayoutCreateInfo* to);
+
+void deepcopy_VkDescriptorPoolSize(
+    Pool* pool,
+    const VkDescriptorPoolSize* from,
+    VkDescriptorPoolSize* to);
+
+void deepcopy_VkDescriptorPoolCreateInfo(
+    Pool* pool,
+    const VkDescriptorPoolCreateInfo* from,
+    VkDescriptorPoolCreateInfo* to);
+
+void deepcopy_VkDescriptorSetAllocateInfo(
+    Pool* pool,
+    const VkDescriptorSetAllocateInfo* from,
+    VkDescriptorSetAllocateInfo* to);
+
+void deepcopy_VkDescriptorImageInfo(
+    Pool* pool,
+    const VkDescriptorImageInfo* from,
+    VkDescriptorImageInfo* to);
+
+void deepcopy_VkDescriptorBufferInfo(
+    Pool* pool,
+    const VkDescriptorBufferInfo* from,
+    VkDescriptorBufferInfo* to);
+
+void deepcopy_VkWriteDescriptorSet(
+    Pool* pool,
+    const VkWriteDescriptorSet* from,
+    VkWriteDescriptorSet* to);
+
+void deepcopy_VkCopyDescriptorSet(
+    Pool* pool,
+    const VkCopyDescriptorSet* from,
+    VkCopyDescriptorSet* to);
+
+void deepcopy_VkFramebufferCreateInfo(
+    Pool* pool,
+    const VkFramebufferCreateInfo* from,
+    VkFramebufferCreateInfo* to);
+
+void deepcopy_VkAttachmentDescription(
+    Pool* pool,
+    const VkAttachmentDescription* from,
+    VkAttachmentDescription* to);
+
+void deepcopy_VkAttachmentReference(
+    Pool* pool,
+    const VkAttachmentReference* from,
+    VkAttachmentReference* to);
+
+void deepcopy_VkSubpassDescription(
+    Pool* pool,
+    const VkSubpassDescription* from,
+    VkSubpassDescription* to);
+
+void deepcopy_VkSubpassDependency(
+    Pool* pool,
+    const VkSubpassDependency* from,
+    VkSubpassDependency* to);
+
+void deepcopy_VkRenderPassCreateInfo(
+    Pool* pool,
+    const VkRenderPassCreateInfo* from,
+    VkRenderPassCreateInfo* to);
+
+void deepcopy_VkCommandPoolCreateInfo(
+    Pool* pool,
+    const VkCommandPoolCreateInfo* from,
+    VkCommandPoolCreateInfo* to);
+
+void deepcopy_VkCommandBufferAllocateInfo(
+    Pool* pool,
+    const VkCommandBufferAllocateInfo* from,
+    VkCommandBufferAllocateInfo* to);
+
+void deepcopy_VkCommandBufferInheritanceInfo(
+    Pool* pool,
+    const VkCommandBufferInheritanceInfo* from,
+    VkCommandBufferInheritanceInfo* to);
+
+void deepcopy_VkCommandBufferBeginInfo(
+    Pool* pool,
+    const VkCommandBufferBeginInfo* from,
+    VkCommandBufferBeginInfo* to);
+
+void deepcopy_VkBufferCopy(
+    Pool* pool,
+    const VkBufferCopy* from,
+    VkBufferCopy* to);
+
+void deepcopy_VkImageSubresourceLayers(
+    Pool* pool,
+    const VkImageSubresourceLayers* from,
+    VkImageSubresourceLayers* to);
+
+void deepcopy_VkImageCopy(
+    Pool* pool,
+    const VkImageCopy* from,
+    VkImageCopy* to);
+
+void deepcopy_VkImageBlit(
+    Pool* pool,
+    const VkImageBlit* from,
+    VkImageBlit* to);
+
+void deepcopy_VkBufferImageCopy(
+    Pool* pool,
+    const VkBufferImageCopy* from,
+    VkBufferImageCopy* to);
+
+void deepcopy_VkClearColorValue(
+    Pool* pool,
+    const VkClearColorValue* from,
+    VkClearColorValue* to);
+
+void deepcopy_VkClearDepthStencilValue(
+    Pool* pool,
+    const VkClearDepthStencilValue* from,
+    VkClearDepthStencilValue* to);
+
+void deepcopy_VkClearValue(
+    Pool* pool,
+    const VkClearValue* from,
+    VkClearValue* to);
+
+void deepcopy_VkClearAttachment(
+    Pool* pool,
+    const VkClearAttachment* from,
+    VkClearAttachment* to);
+
+void deepcopy_VkClearRect(
+    Pool* pool,
+    const VkClearRect* from,
+    VkClearRect* to);
+
+void deepcopy_VkImageResolve(
+    Pool* pool,
+    const VkImageResolve* from,
+    VkImageResolve* to);
+
+void deepcopy_VkMemoryBarrier(
+    Pool* pool,
+    const VkMemoryBarrier* from,
+    VkMemoryBarrier* to);
+
+void deepcopy_VkBufferMemoryBarrier(
+    Pool* pool,
+    const VkBufferMemoryBarrier* from,
+    VkBufferMemoryBarrier* to);
+
+void deepcopy_VkImageMemoryBarrier(
+    Pool* pool,
+    const VkImageMemoryBarrier* from,
+    VkImageMemoryBarrier* to);
+
+void deepcopy_VkRenderPassBeginInfo(
+    Pool* pool,
+    const VkRenderPassBeginInfo* from,
+    VkRenderPassBeginInfo* to);
+
+void deepcopy_VkDispatchIndirectCommand(
+    Pool* pool,
+    const VkDispatchIndirectCommand* from,
+    VkDispatchIndirectCommand* to);
+
+void deepcopy_VkDrawIndexedIndirectCommand(
+    Pool* pool,
+    const VkDrawIndexedIndirectCommand* from,
+    VkDrawIndexedIndirectCommand* to);
+
+void deepcopy_VkDrawIndirectCommand(
+    Pool* pool,
+    const VkDrawIndirectCommand* from,
+    VkDrawIndirectCommand* to);
+
+void deepcopy_VkBaseOutStructure(
+    Pool* pool,
+    const VkBaseOutStructure* from,
+    VkBaseOutStructure* to);
+
+void deepcopy_VkBaseInStructure(
+    Pool* pool,
+    const VkBaseInStructure* from,
+    VkBaseInStructure* to);
+
+#endif
+#ifdef VK_VERSION_1_1
+void deepcopy_VkPhysicalDeviceSubgroupProperties(
+    Pool* pool,
+    const VkPhysicalDeviceSubgroupProperties* from,
+    VkPhysicalDeviceSubgroupProperties* to);
+
+void deepcopy_VkBindBufferMemoryInfo(
+    Pool* pool,
+    const VkBindBufferMemoryInfo* from,
+    VkBindBufferMemoryInfo* to);
+
+void deepcopy_VkBindImageMemoryInfo(
+    Pool* pool,
+    const VkBindImageMemoryInfo* from,
+    VkBindImageMemoryInfo* to);
+
+void deepcopy_VkPhysicalDevice16BitStorageFeatures(
+    Pool* pool,
+    const VkPhysicalDevice16BitStorageFeatures* from,
+    VkPhysicalDevice16BitStorageFeatures* to);
+
+void deepcopy_VkMemoryDedicatedRequirements(
+    Pool* pool,
+    const VkMemoryDedicatedRequirements* from,
+    VkMemoryDedicatedRequirements* to);
+
+void deepcopy_VkMemoryDedicatedAllocateInfo(
+    Pool* pool,
+    const VkMemoryDedicatedAllocateInfo* from,
+    VkMemoryDedicatedAllocateInfo* to);
+
+void deepcopy_VkMemoryAllocateFlagsInfo(
+    Pool* pool,
+    const VkMemoryAllocateFlagsInfo* from,
+    VkMemoryAllocateFlagsInfo* to);
+
+void deepcopy_VkDeviceGroupRenderPassBeginInfo(
+    Pool* pool,
+    const VkDeviceGroupRenderPassBeginInfo* from,
+    VkDeviceGroupRenderPassBeginInfo* to);
+
+void deepcopy_VkDeviceGroupCommandBufferBeginInfo(
+    Pool* pool,
+    const VkDeviceGroupCommandBufferBeginInfo* from,
+    VkDeviceGroupCommandBufferBeginInfo* to);
+
+void deepcopy_VkDeviceGroupSubmitInfo(
+    Pool* pool,
+    const VkDeviceGroupSubmitInfo* from,
+    VkDeviceGroupSubmitInfo* to);
+
+void deepcopy_VkDeviceGroupBindSparseInfo(
+    Pool* pool,
+    const VkDeviceGroupBindSparseInfo* from,
+    VkDeviceGroupBindSparseInfo* to);
+
+void deepcopy_VkBindBufferMemoryDeviceGroupInfo(
+    Pool* pool,
+    const VkBindBufferMemoryDeviceGroupInfo* from,
+    VkBindBufferMemoryDeviceGroupInfo* to);
+
+void deepcopy_VkBindImageMemoryDeviceGroupInfo(
+    Pool* pool,
+    const VkBindImageMemoryDeviceGroupInfo* from,
+    VkBindImageMemoryDeviceGroupInfo* to);
+
+void deepcopy_VkPhysicalDeviceGroupProperties(
+    Pool* pool,
+    const VkPhysicalDeviceGroupProperties* from,
+    VkPhysicalDeviceGroupProperties* to);
+
+void deepcopy_VkDeviceGroupDeviceCreateInfo(
+    Pool* pool,
+    const VkDeviceGroupDeviceCreateInfo* from,
+    VkDeviceGroupDeviceCreateInfo* to);
+
+void deepcopy_VkBufferMemoryRequirementsInfo2(
+    Pool* pool,
+    const VkBufferMemoryRequirementsInfo2* from,
+    VkBufferMemoryRequirementsInfo2* to);
+
+void deepcopy_VkImageMemoryRequirementsInfo2(
+    Pool* pool,
+    const VkImageMemoryRequirementsInfo2* from,
+    VkImageMemoryRequirementsInfo2* to);
+
+void deepcopy_VkImageSparseMemoryRequirementsInfo2(
+    Pool* pool,
+    const VkImageSparseMemoryRequirementsInfo2* from,
+    VkImageSparseMemoryRequirementsInfo2* to);
+
+void deepcopy_VkMemoryRequirements2(
+    Pool* pool,
+    const VkMemoryRequirements2* from,
+    VkMemoryRequirements2* to);
+
+void deepcopy_VkSparseImageMemoryRequirements2(
+    Pool* pool,
+    const VkSparseImageMemoryRequirements2* from,
+    VkSparseImageMemoryRequirements2* to);
+
+void deepcopy_VkPhysicalDeviceFeatures2(
+    Pool* pool,
+    const VkPhysicalDeviceFeatures2* from,
+    VkPhysicalDeviceFeatures2* to);
+
+void deepcopy_VkPhysicalDeviceProperties2(
+    Pool* pool,
+    const VkPhysicalDeviceProperties2* from,
+    VkPhysicalDeviceProperties2* to);
+
+void deepcopy_VkFormatProperties2(
+    Pool* pool,
+    const VkFormatProperties2* from,
+    VkFormatProperties2* to);
+
+void deepcopy_VkImageFormatProperties2(
+    Pool* pool,
+    const VkImageFormatProperties2* from,
+    VkImageFormatProperties2* to);
+
+void deepcopy_VkPhysicalDeviceImageFormatInfo2(
+    Pool* pool,
+    const VkPhysicalDeviceImageFormatInfo2* from,
+    VkPhysicalDeviceImageFormatInfo2* to);
+
+void deepcopy_VkQueueFamilyProperties2(
+    Pool* pool,
+    const VkQueueFamilyProperties2* from,
+    VkQueueFamilyProperties2* to);
+
+void deepcopy_VkPhysicalDeviceMemoryProperties2(
+    Pool* pool,
+    const VkPhysicalDeviceMemoryProperties2* from,
+    VkPhysicalDeviceMemoryProperties2* to);
+
+void deepcopy_VkSparseImageFormatProperties2(
+    Pool* pool,
+    const VkSparseImageFormatProperties2* from,
+    VkSparseImageFormatProperties2* to);
+
+void deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
+    Pool* pool,
+    const VkPhysicalDeviceSparseImageFormatInfo2* from,
+    VkPhysicalDeviceSparseImageFormatInfo2* to);
+
+void deepcopy_VkPhysicalDevicePointClippingProperties(
+    Pool* pool,
+    const VkPhysicalDevicePointClippingProperties* from,
+    VkPhysicalDevicePointClippingProperties* to);
+
+void deepcopy_VkInputAttachmentAspectReference(
+    Pool* pool,
+    const VkInputAttachmentAspectReference* from,
+    VkInputAttachmentAspectReference* to);
+
+void deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
+    Pool* pool,
+    const VkRenderPassInputAttachmentAspectCreateInfo* from,
+    VkRenderPassInputAttachmentAspectCreateInfo* to);
+
+void deepcopy_VkImageViewUsageCreateInfo(
+    Pool* pool,
+    const VkImageViewUsageCreateInfo* from,
+    VkImageViewUsageCreateInfo* to);
+
+void deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
+    Pool* pool,
+    const VkPipelineTessellationDomainOriginStateCreateInfo* from,
+    VkPipelineTessellationDomainOriginStateCreateInfo* to);
+
+void deepcopy_VkRenderPassMultiviewCreateInfo(
+    Pool* pool,
+    const VkRenderPassMultiviewCreateInfo* from,
+    VkRenderPassMultiviewCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceMultiviewFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceMultiviewFeatures* from,
+    VkPhysicalDeviceMultiviewFeatures* to);
+
+void deepcopy_VkPhysicalDeviceMultiviewProperties(
+    Pool* pool,
+    const VkPhysicalDeviceMultiviewProperties* from,
+    VkPhysicalDeviceMultiviewProperties* to);
+
+void deepcopy_VkPhysicalDeviceVariablePointerFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceVariablePointerFeatures* from,
+    VkPhysicalDeviceVariablePointerFeatures* to);
+
+void deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceProtectedMemoryFeatures* from,
+    VkPhysicalDeviceProtectedMemoryFeatures* to);
+
+void deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
+    Pool* pool,
+    const VkPhysicalDeviceProtectedMemoryProperties* from,
+    VkPhysicalDeviceProtectedMemoryProperties* to);
+
+void deepcopy_VkDeviceQueueInfo2(
+    Pool* pool,
+    const VkDeviceQueueInfo2* from,
+    VkDeviceQueueInfo2* to);
+
+void deepcopy_VkProtectedSubmitInfo(
+    Pool* pool,
+    const VkProtectedSubmitInfo* from,
+    VkProtectedSubmitInfo* to);
+
+void deepcopy_VkSamplerYcbcrConversionCreateInfo(
+    Pool* pool,
+    const VkSamplerYcbcrConversionCreateInfo* from,
+    VkSamplerYcbcrConversionCreateInfo* to);
+
+void deepcopy_VkSamplerYcbcrConversionInfo(
+    Pool* pool,
+    const VkSamplerYcbcrConversionInfo* from,
+    VkSamplerYcbcrConversionInfo* to);
+
+void deepcopy_VkBindImagePlaneMemoryInfo(
+    Pool* pool,
+    const VkBindImagePlaneMemoryInfo* from,
+    VkBindImagePlaneMemoryInfo* to);
+
+void deepcopy_VkImagePlaneMemoryRequirementsInfo(
+    Pool* pool,
+    const VkImagePlaneMemoryRequirementsInfo* from,
+    VkImagePlaneMemoryRequirementsInfo* to);
+
+void deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* from,
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures* to);
+
+void deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
+    Pool* pool,
+    const VkSamplerYcbcrConversionImageFormatProperties* from,
+    VkSamplerYcbcrConversionImageFormatProperties* to);
+
+void deepcopy_VkDescriptorUpdateTemplateEntry(
+    Pool* pool,
+    const VkDescriptorUpdateTemplateEntry* from,
+    VkDescriptorUpdateTemplateEntry* to);
+
+void deepcopy_VkDescriptorUpdateTemplateCreateInfo(
+    Pool* pool,
+    const VkDescriptorUpdateTemplateCreateInfo* from,
+    VkDescriptorUpdateTemplateCreateInfo* to);
+
+void deepcopy_VkExternalMemoryProperties(
+    Pool* pool,
+    const VkExternalMemoryProperties* from,
+    VkExternalMemoryProperties* to);
+
+void deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
+    Pool* pool,
+    const VkPhysicalDeviceExternalImageFormatInfo* from,
+    VkPhysicalDeviceExternalImageFormatInfo* to);
+
+void deepcopy_VkExternalImageFormatProperties(
+    Pool* pool,
+    const VkExternalImageFormatProperties* from,
+    VkExternalImageFormatProperties* to);
+
+void deepcopy_VkPhysicalDeviceExternalBufferInfo(
+    Pool* pool,
+    const VkPhysicalDeviceExternalBufferInfo* from,
+    VkPhysicalDeviceExternalBufferInfo* to);
+
+void deepcopy_VkExternalBufferProperties(
+    Pool* pool,
+    const VkExternalBufferProperties* from,
+    VkExternalBufferProperties* to);
+
+void deepcopy_VkPhysicalDeviceIDProperties(
+    Pool* pool,
+    const VkPhysicalDeviceIDProperties* from,
+    VkPhysicalDeviceIDProperties* to);
+
+void deepcopy_VkExternalMemoryImageCreateInfo(
+    Pool* pool,
+    const VkExternalMemoryImageCreateInfo* from,
+    VkExternalMemoryImageCreateInfo* to);
+
+void deepcopy_VkExternalMemoryBufferCreateInfo(
+    Pool* pool,
+    const VkExternalMemoryBufferCreateInfo* from,
+    VkExternalMemoryBufferCreateInfo* to);
+
+void deepcopy_VkExportMemoryAllocateInfo(
+    Pool* pool,
+    const VkExportMemoryAllocateInfo* from,
+    VkExportMemoryAllocateInfo* to);
+
+void deepcopy_VkPhysicalDeviceExternalFenceInfo(
+    Pool* pool,
+    const VkPhysicalDeviceExternalFenceInfo* from,
+    VkPhysicalDeviceExternalFenceInfo* to);
+
+void deepcopy_VkExternalFenceProperties(
+    Pool* pool,
+    const VkExternalFenceProperties* from,
+    VkExternalFenceProperties* to);
+
+void deepcopy_VkExportFenceCreateInfo(
+    Pool* pool,
+    const VkExportFenceCreateInfo* from,
+    VkExportFenceCreateInfo* to);
+
+void deepcopy_VkExportSemaphoreCreateInfo(
+    Pool* pool,
+    const VkExportSemaphoreCreateInfo* from,
+    VkExportSemaphoreCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
+    Pool* pool,
+    const VkPhysicalDeviceExternalSemaphoreInfo* from,
+    VkPhysicalDeviceExternalSemaphoreInfo* to);
+
+void deepcopy_VkExternalSemaphoreProperties(
+    Pool* pool,
+    const VkExternalSemaphoreProperties* from,
+    VkExternalSemaphoreProperties* to);
+
+void deepcopy_VkPhysicalDeviceMaintenance3Properties(
+    Pool* pool,
+    const VkPhysicalDeviceMaintenance3Properties* from,
+    VkPhysicalDeviceMaintenance3Properties* to);
+
+void deepcopy_VkDescriptorSetLayoutSupport(
+    Pool* pool,
+    const VkDescriptorSetLayoutSupport* from,
+    VkDescriptorSetLayoutSupport* to);
+
+void deepcopy_VkPhysicalDeviceShaderDrawParameterFeatures(
+    Pool* pool,
+    const VkPhysicalDeviceShaderDrawParameterFeatures* from,
+    VkPhysicalDeviceShaderDrawParameterFeatures* to);
+
+#endif
+#ifdef VK_KHR_surface
+void deepcopy_VkSurfaceCapabilitiesKHR(
+    Pool* pool,
+    const VkSurfaceCapabilitiesKHR* from,
+    VkSurfaceCapabilitiesKHR* to);
+
+void deepcopy_VkSurfaceFormatKHR(
+    Pool* pool,
+    const VkSurfaceFormatKHR* from,
+    VkSurfaceFormatKHR* to);
+
+#endif
+#ifdef VK_KHR_swapchain
+void deepcopy_VkSwapchainCreateInfoKHR(
+    Pool* pool,
+    const VkSwapchainCreateInfoKHR* from,
+    VkSwapchainCreateInfoKHR* to);
+
+void deepcopy_VkPresentInfoKHR(
+    Pool* pool,
+    const VkPresentInfoKHR* from,
+    VkPresentInfoKHR* to);
+
+void deepcopy_VkImageSwapchainCreateInfoKHR(
+    Pool* pool,
+    const VkImageSwapchainCreateInfoKHR* from,
+    VkImageSwapchainCreateInfoKHR* to);
+
+void deepcopy_VkBindImageMemorySwapchainInfoKHR(
+    Pool* pool,
+    const VkBindImageMemorySwapchainInfoKHR* from,
+    VkBindImageMemorySwapchainInfoKHR* to);
+
+void deepcopy_VkAcquireNextImageInfoKHR(
+    Pool* pool,
+    const VkAcquireNextImageInfoKHR* from,
+    VkAcquireNextImageInfoKHR* to);
+
+void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(
+    Pool* pool,
+    const VkDeviceGroupPresentCapabilitiesKHR* from,
+    VkDeviceGroupPresentCapabilitiesKHR* to);
+
+void deepcopy_VkDeviceGroupPresentInfoKHR(
+    Pool* pool,
+    const VkDeviceGroupPresentInfoKHR* from,
+    VkDeviceGroupPresentInfoKHR* to);
+
+void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(
+    Pool* pool,
+    const VkDeviceGroupSwapchainCreateInfoKHR* from,
+    VkDeviceGroupSwapchainCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_display
+void deepcopy_VkDisplayPropertiesKHR(
+    Pool* pool,
+    const VkDisplayPropertiesKHR* from,
+    VkDisplayPropertiesKHR* to);
+
+void deepcopy_VkDisplayModeParametersKHR(
+    Pool* pool,
+    const VkDisplayModeParametersKHR* from,
+    VkDisplayModeParametersKHR* to);
+
+void deepcopy_VkDisplayModePropertiesKHR(
+    Pool* pool,
+    const VkDisplayModePropertiesKHR* from,
+    VkDisplayModePropertiesKHR* to);
+
+void deepcopy_VkDisplayModeCreateInfoKHR(
+    Pool* pool,
+    const VkDisplayModeCreateInfoKHR* from,
+    VkDisplayModeCreateInfoKHR* to);
+
+void deepcopy_VkDisplayPlaneCapabilitiesKHR(
+    Pool* pool,
+    const VkDisplayPlaneCapabilitiesKHR* from,
+    VkDisplayPlaneCapabilitiesKHR* to);
+
+void deepcopy_VkDisplayPlanePropertiesKHR(
+    Pool* pool,
+    const VkDisplayPlanePropertiesKHR* from,
+    VkDisplayPlanePropertiesKHR* to);
+
+void deepcopy_VkDisplaySurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkDisplaySurfaceCreateInfoKHR* from,
+    VkDisplaySurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_display_swapchain
+void deepcopy_VkDisplayPresentInfoKHR(
+    Pool* pool,
+    const VkDisplayPresentInfoKHR* from,
+    VkDisplayPresentInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_xlib_surface
+void deepcopy_VkXlibSurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkXlibSurfaceCreateInfoKHR* from,
+    VkXlibSurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_xcb_surface
+void deepcopy_VkXcbSurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkXcbSurfaceCreateInfoKHR* from,
+    VkXcbSurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_wayland_surface
+void deepcopy_VkWaylandSurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkWaylandSurfaceCreateInfoKHR* from,
+    VkWaylandSurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_mir_surface
+void deepcopy_VkMirSurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkMirSurfaceCreateInfoKHR* from,
+    VkMirSurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_android_surface
+void deepcopy_VkAndroidSurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkAndroidSurfaceCreateInfoKHR* from,
+    VkAndroidSurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_win32_surface
+void deepcopy_VkWin32SurfaceCreateInfoKHR(
+    Pool* pool,
+    const VkWin32SurfaceCreateInfoKHR* from,
+    VkWin32SurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void deepcopy_VkImportMemoryWin32HandleInfoKHR(
+    Pool* pool,
+    const VkImportMemoryWin32HandleInfoKHR* from,
+    VkImportMemoryWin32HandleInfoKHR* to);
+
+void deepcopy_VkExportMemoryWin32HandleInfoKHR(
+    Pool* pool,
+    const VkExportMemoryWin32HandleInfoKHR* from,
+    VkExportMemoryWin32HandleInfoKHR* to);
+
+void deepcopy_VkMemoryWin32HandlePropertiesKHR(
+    Pool* pool,
+    const VkMemoryWin32HandlePropertiesKHR* from,
+    VkMemoryWin32HandlePropertiesKHR* to);
+
+void deepcopy_VkMemoryGetWin32HandleInfoKHR(
+    Pool* pool,
+    const VkMemoryGetWin32HandleInfoKHR* from,
+    VkMemoryGetWin32HandleInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+void deepcopy_VkImportMemoryFdInfoKHR(
+    Pool* pool,
+    const VkImportMemoryFdInfoKHR* from,
+    VkImportMemoryFdInfoKHR* to);
+
+void deepcopy_VkMemoryFdPropertiesKHR(
+    Pool* pool,
+    const VkMemoryFdPropertiesKHR* from,
+    VkMemoryFdPropertiesKHR* to);
+
+void deepcopy_VkMemoryGetFdInfoKHR(
+    Pool* pool,
+    const VkMemoryGetFdInfoKHR* from,
+    VkMemoryGetFdInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+    Pool* pool,
+    const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
+    VkWin32KeyedMutexAcquireReleaseInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(
+    Pool* pool,
+    const VkImportSemaphoreWin32HandleInfoKHR* from,
+    VkImportSemaphoreWin32HandleInfoKHR* to);
+
+void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(
+    Pool* pool,
+    const VkExportSemaphoreWin32HandleInfoKHR* from,
+    VkExportSemaphoreWin32HandleInfoKHR* to);
+
+void deepcopy_VkD3D12FenceSubmitInfoKHR(
+    Pool* pool,
+    const VkD3D12FenceSubmitInfoKHR* from,
+    VkD3D12FenceSubmitInfoKHR* to);
+
+void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(
+    Pool* pool,
+    const VkSemaphoreGetWin32HandleInfoKHR* from,
+    VkSemaphoreGetWin32HandleInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void deepcopy_VkImportSemaphoreFdInfoKHR(
+    Pool* pool,
+    const VkImportSemaphoreFdInfoKHR* from,
+    VkImportSemaphoreFdInfoKHR* to);
+
+void deepcopy_VkSemaphoreGetFdInfoKHR(
+    Pool* pool,
+    const VkSemaphoreGetFdInfoKHR* from,
+    VkSemaphoreGetFdInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
+    Pool* pool,
+    const VkPhysicalDevicePushDescriptorPropertiesKHR* from,
+    VkPhysicalDevicePushDescriptorPropertiesKHR* to);
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void deepcopy_VkRectLayerKHR(
+    Pool* pool,
+    const VkRectLayerKHR* from,
+    VkRectLayerKHR* to);
+
+void deepcopy_VkPresentRegionKHR(
+    Pool* pool,
+    const VkPresentRegionKHR* from,
+    VkPresentRegionKHR* to);
+
+void deepcopy_VkPresentRegionsKHR(
+    Pool* pool,
+    const VkPresentRegionsKHR* from,
+    VkPresentRegionsKHR* to);
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+void deepcopy_VkAttachmentDescription2KHR(
+    Pool* pool,
+    const VkAttachmentDescription2KHR* from,
+    VkAttachmentDescription2KHR* to);
+
+void deepcopy_VkAttachmentReference2KHR(
+    Pool* pool,
+    const VkAttachmentReference2KHR* from,
+    VkAttachmentReference2KHR* to);
+
+void deepcopy_VkSubpassDescription2KHR(
+    Pool* pool,
+    const VkSubpassDescription2KHR* from,
+    VkSubpassDescription2KHR* to);
+
+void deepcopy_VkSubpassDependency2KHR(
+    Pool* pool,
+    const VkSubpassDependency2KHR* from,
+    VkSubpassDependency2KHR* to);
+
+void deepcopy_VkRenderPassCreateInfo2KHR(
+    Pool* pool,
+    const VkRenderPassCreateInfo2KHR* from,
+    VkRenderPassCreateInfo2KHR* to);
+
+void deepcopy_VkSubpassBeginInfoKHR(
+    Pool* pool,
+    const VkSubpassBeginInfoKHR* from,
+    VkSubpassBeginInfoKHR* to);
+
+void deepcopy_VkSubpassEndInfoKHR(
+    Pool* pool,
+    const VkSubpassEndInfoKHR* from,
+    VkSubpassEndInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
+    Pool* pool,
+    const VkSharedPresentSurfaceCapabilitiesKHR* from,
+    VkSharedPresentSurfaceCapabilitiesKHR* to);
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void deepcopy_VkImportFenceWin32HandleInfoKHR(
+    Pool* pool,
+    const VkImportFenceWin32HandleInfoKHR* from,
+    VkImportFenceWin32HandleInfoKHR* to);
+
+void deepcopy_VkExportFenceWin32HandleInfoKHR(
+    Pool* pool,
+    const VkExportFenceWin32HandleInfoKHR* from,
+    VkExportFenceWin32HandleInfoKHR* to);
+
+void deepcopy_VkFenceGetWin32HandleInfoKHR(
+    Pool* pool,
+    const VkFenceGetWin32HandleInfoKHR* from,
+    VkFenceGetWin32HandleInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+void deepcopy_VkImportFenceFdInfoKHR(
+    Pool* pool,
+    const VkImportFenceFdInfoKHR* from,
+    VkImportFenceFdInfoKHR* to);
+
+void deepcopy_VkFenceGetFdInfoKHR(
+    Pool* pool,
+    const VkFenceGetFdInfoKHR* from,
+    VkFenceGetFdInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
+    Pool* pool,
+    const VkPhysicalDeviceSurfaceInfo2KHR* from,
+    VkPhysicalDeviceSurfaceInfo2KHR* to);
+
+void deepcopy_VkSurfaceCapabilities2KHR(
+    Pool* pool,
+    const VkSurfaceCapabilities2KHR* from,
+    VkSurfaceCapabilities2KHR* to);
+
+void deepcopy_VkSurfaceFormat2KHR(
+    Pool* pool,
+    const VkSurfaceFormat2KHR* from,
+    VkSurfaceFormat2KHR* to);
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void deepcopy_VkDisplayProperties2KHR(
+    Pool* pool,
+    const VkDisplayProperties2KHR* from,
+    VkDisplayProperties2KHR* to);
+
+void deepcopy_VkDisplayPlaneProperties2KHR(
+    Pool* pool,
+    const VkDisplayPlaneProperties2KHR* from,
+    VkDisplayPlaneProperties2KHR* to);
+
+void deepcopy_VkDisplayModeProperties2KHR(
+    Pool* pool,
+    const VkDisplayModeProperties2KHR* from,
+    VkDisplayModeProperties2KHR* to);
+
+void deepcopy_VkDisplayPlaneInfo2KHR(
+    Pool* pool,
+    const VkDisplayPlaneInfo2KHR* from,
+    VkDisplayPlaneInfo2KHR* to);
+
+void deepcopy_VkDisplayPlaneCapabilities2KHR(
+    Pool* pool,
+    const VkDisplayPlaneCapabilities2KHR* from,
+    VkDisplayPlaneCapabilities2KHR* to);
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+void deepcopy_VkImageFormatListCreateInfoKHR(
+    Pool* pool,
+    const VkImageFormatListCreateInfoKHR* from,
+    VkImageFormatListCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+void deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR(
+    Pool* pool,
+    const VkPhysicalDevice8BitStorageFeaturesKHR* from,
+    VkPhysicalDevice8BitStorageFeaturesKHR* to);
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void deepcopy_VkNativeBufferANDROID(
+    Pool* pool,
+    const VkNativeBufferANDROID* from,
+    VkNativeBufferANDROID* to);
+
+#endif
+#ifdef VK_EXT_debug_report
+void deepcopy_VkDebugReportCallbackCreateInfoEXT(
+    Pool* pool,
+    const VkDebugReportCallbackCreateInfoEXT* from,
+    VkDebugReportCallbackCreateInfoEXT* to);
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
+    Pool* pool,
+    const VkPipelineRasterizationStateRasterizationOrderAMD* from,
+    VkPipelineRasterizationStateRasterizationOrderAMD* to);
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void deepcopy_VkDebugMarkerObjectNameInfoEXT(
+    Pool* pool,
+    const VkDebugMarkerObjectNameInfoEXT* from,
+    VkDebugMarkerObjectNameInfoEXT* to);
+
+void deepcopy_VkDebugMarkerObjectTagInfoEXT(
+    Pool* pool,
+    const VkDebugMarkerObjectTagInfoEXT* from,
+    VkDebugMarkerObjectTagInfoEXT* to);
+
+void deepcopy_VkDebugMarkerMarkerInfoEXT(
+    Pool* pool,
+    const VkDebugMarkerMarkerInfoEXT* from,
+    VkDebugMarkerMarkerInfoEXT* to);
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void deepcopy_VkDedicatedAllocationImageCreateInfoNV(
+    Pool* pool,
+    const VkDedicatedAllocationImageCreateInfoNV* from,
+    VkDedicatedAllocationImageCreateInfoNV* to);
+
+void deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
+    Pool* pool,
+    const VkDedicatedAllocationBufferCreateInfoNV* from,
+    VkDedicatedAllocationBufferCreateInfoNV* to);
+
+void deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
+    Pool* pool,
+    const VkDedicatedAllocationMemoryAllocateInfoNV* from,
+    VkDedicatedAllocationMemoryAllocateInfoNV* to);
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void deepcopy_VkTextureLODGatherFormatPropertiesAMD(
+    Pool* pool,
+    const VkTextureLODGatherFormatPropertiesAMD* from,
+    VkTextureLODGatherFormatPropertiesAMD* to);
+
+#endif
+#ifdef VK_AMD_shader_info
+void deepcopy_VkShaderResourceUsageAMD(
+    Pool* pool,
+    const VkShaderResourceUsageAMD* from,
+    VkShaderResourceUsageAMD* to);
+
+void deepcopy_VkShaderStatisticsInfoAMD(
+    Pool* pool,
+    const VkShaderStatisticsInfoAMD* from,
+    VkShaderStatisticsInfoAMD* to);
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void deepcopy_VkExternalImageFormatPropertiesNV(
+    Pool* pool,
+    const VkExternalImageFormatPropertiesNV* from,
+    VkExternalImageFormatPropertiesNV* to);
+
+#endif
+#ifdef VK_NV_external_memory
+void deepcopy_VkExternalMemoryImageCreateInfoNV(
+    Pool* pool,
+    const VkExternalMemoryImageCreateInfoNV* from,
+    VkExternalMemoryImageCreateInfoNV* to);
+
+void deepcopy_VkExportMemoryAllocateInfoNV(
+    Pool* pool,
+    const VkExportMemoryAllocateInfoNV* from,
+    VkExportMemoryAllocateInfoNV* to);
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void deepcopy_VkImportMemoryWin32HandleInfoNV(
+    Pool* pool,
+    const VkImportMemoryWin32HandleInfoNV* from,
+    VkImportMemoryWin32HandleInfoNV* to);
+
+void deepcopy_VkExportMemoryWin32HandleInfoNV(
+    Pool* pool,
+    const VkExportMemoryWin32HandleInfoNV* from,
+    VkExportMemoryWin32HandleInfoNV* to);
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
+    Pool* pool,
+    const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
+    VkWin32KeyedMutexAcquireReleaseInfoNV* to);
+
+#endif
+#ifdef VK_EXT_validation_flags
+void deepcopy_VkValidationFlagsEXT(
+    Pool* pool,
+    const VkValidationFlagsEXT* from,
+    VkValidationFlagsEXT* to);
+
+#endif
+#ifdef VK_NN_vi_surface
+void deepcopy_VkViSurfaceCreateInfoNN(
+    Pool* pool,
+    const VkViSurfaceCreateInfoNN* from,
+    VkViSurfaceCreateInfoNN* to);
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void deepcopy_VkConditionalRenderingBeginInfoEXT(
+    Pool* pool,
+    const VkConditionalRenderingBeginInfoEXT* from,
+    VkConditionalRenderingBeginInfoEXT* to);
+
+void deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* from,
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT* to);
+
+void deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+    Pool* pool,
+    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* from,
+    VkCommandBufferInheritanceConditionalRenderingInfoEXT* to);
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void deepcopy_VkDeviceGeneratedCommandsFeaturesNVX(
+    Pool* pool,
+    const VkDeviceGeneratedCommandsFeaturesNVX* from,
+    VkDeviceGeneratedCommandsFeaturesNVX* to);
+
+void deepcopy_VkDeviceGeneratedCommandsLimitsNVX(
+    Pool* pool,
+    const VkDeviceGeneratedCommandsLimitsNVX* from,
+    VkDeviceGeneratedCommandsLimitsNVX* to);
+
+void deepcopy_VkIndirectCommandsTokenNVX(
+    Pool* pool,
+    const VkIndirectCommandsTokenNVX* from,
+    VkIndirectCommandsTokenNVX* to);
+
+void deepcopy_VkIndirectCommandsLayoutTokenNVX(
+    Pool* pool,
+    const VkIndirectCommandsLayoutTokenNVX* from,
+    VkIndirectCommandsLayoutTokenNVX* to);
+
+void deepcopy_VkIndirectCommandsLayoutCreateInfoNVX(
+    Pool* pool,
+    const VkIndirectCommandsLayoutCreateInfoNVX* from,
+    VkIndirectCommandsLayoutCreateInfoNVX* to);
+
+void deepcopy_VkCmdProcessCommandsInfoNVX(
+    Pool* pool,
+    const VkCmdProcessCommandsInfoNVX* from,
+    VkCmdProcessCommandsInfoNVX* to);
+
+void deepcopy_VkCmdReserveSpaceForCommandsInfoNVX(
+    Pool* pool,
+    const VkCmdReserveSpaceForCommandsInfoNVX* from,
+    VkCmdReserveSpaceForCommandsInfoNVX* to);
+
+void deepcopy_VkObjectTableCreateInfoNVX(
+    Pool* pool,
+    const VkObjectTableCreateInfoNVX* from,
+    VkObjectTableCreateInfoNVX* to);
+
+void deepcopy_VkObjectTableEntryNVX(
+    Pool* pool,
+    const VkObjectTableEntryNVX* from,
+    VkObjectTableEntryNVX* to);
+
+void deepcopy_VkObjectTablePipelineEntryNVX(
+    Pool* pool,
+    const VkObjectTablePipelineEntryNVX* from,
+    VkObjectTablePipelineEntryNVX* to);
+
+void deepcopy_VkObjectTableDescriptorSetEntryNVX(
+    Pool* pool,
+    const VkObjectTableDescriptorSetEntryNVX* from,
+    VkObjectTableDescriptorSetEntryNVX* to);
+
+void deepcopy_VkObjectTableVertexBufferEntryNVX(
+    Pool* pool,
+    const VkObjectTableVertexBufferEntryNVX* from,
+    VkObjectTableVertexBufferEntryNVX* to);
+
+void deepcopy_VkObjectTableIndexBufferEntryNVX(
+    Pool* pool,
+    const VkObjectTableIndexBufferEntryNVX* from,
+    VkObjectTableIndexBufferEntryNVX* to);
+
+void deepcopy_VkObjectTablePushConstantEntryNVX(
+    Pool* pool,
+    const VkObjectTablePushConstantEntryNVX* from,
+    VkObjectTablePushConstantEntryNVX* to);
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void deepcopy_VkViewportWScalingNV(
+    Pool* pool,
+    const VkViewportWScalingNV* from,
+    VkViewportWScalingNV* to);
+
+void deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
+    Pool* pool,
+    const VkPipelineViewportWScalingStateCreateInfoNV* from,
+    VkPipelineViewportWScalingStateCreateInfoNV* to);
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+void deepcopy_VkSurfaceCapabilities2EXT(
+    Pool* pool,
+    const VkSurfaceCapabilities2EXT* from,
+    VkSurfaceCapabilities2EXT* to);
+
+#endif
+#ifdef VK_EXT_display_control
+void deepcopy_VkDisplayPowerInfoEXT(
+    Pool* pool,
+    const VkDisplayPowerInfoEXT* from,
+    VkDisplayPowerInfoEXT* to);
+
+void deepcopy_VkDeviceEventInfoEXT(
+    Pool* pool,
+    const VkDeviceEventInfoEXT* from,
+    VkDeviceEventInfoEXT* to);
+
+void deepcopy_VkDisplayEventInfoEXT(
+    Pool* pool,
+    const VkDisplayEventInfoEXT* from,
+    VkDisplayEventInfoEXT* to);
+
+void deepcopy_VkSwapchainCounterCreateInfoEXT(
+    Pool* pool,
+    const VkSwapchainCounterCreateInfoEXT* from,
+    VkSwapchainCounterCreateInfoEXT* to);
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+void deepcopy_VkRefreshCycleDurationGOOGLE(
+    Pool* pool,
+    const VkRefreshCycleDurationGOOGLE* from,
+    VkRefreshCycleDurationGOOGLE* to);
+
+void deepcopy_VkPastPresentationTimingGOOGLE(
+    Pool* pool,
+    const VkPastPresentationTimingGOOGLE* from,
+    VkPastPresentationTimingGOOGLE* to);
+
+void deepcopy_VkPresentTimeGOOGLE(
+    Pool* pool,
+    const VkPresentTimeGOOGLE* from,
+    VkPresentTimeGOOGLE* to);
+
+void deepcopy_VkPresentTimesInfoGOOGLE(
+    Pool* pool,
+    const VkPresentTimesInfoGOOGLE* from,
+    VkPresentTimesInfoGOOGLE* to);
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    Pool* pool,
+    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* from,
+    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to);
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void deepcopy_VkViewportSwizzleNV(
+    Pool* pool,
+    const VkViewportSwizzleNV* from,
+    VkViewportSwizzleNV* to);
+
+void deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
+    Pool* pool,
+    const VkPipelineViewportSwizzleStateCreateInfoNV* from,
+    VkPipelineViewportSwizzleStateCreateInfoNV* to);
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* from,
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT* to);
+
+void deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
+    Pool* pool,
+    const VkPipelineDiscardRectangleStateCreateInfoEXT* from,
+    VkPipelineDiscardRectangleStateCreateInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* from,
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to);
+
+void deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+    Pool* pool,
+    const VkPipelineRasterizationConservativeStateCreateInfoEXT* from,
+    VkPipelineRasterizationConservativeStateCreateInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void deepcopy_VkXYColorEXT(
+    Pool* pool,
+    const VkXYColorEXT* from,
+    VkXYColorEXT* to);
+
+void deepcopy_VkHdrMetadataEXT(
+    Pool* pool,
+    const VkHdrMetadataEXT* from,
+    VkHdrMetadataEXT* to);
+
+#endif
+#ifdef VK_MVK_ios_surface
+void deepcopy_VkIOSSurfaceCreateInfoMVK(
+    Pool* pool,
+    const VkIOSSurfaceCreateInfoMVK* from,
+    VkIOSSurfaceCreateInfoMVK* to);
+
+#endif
+#ifdef VK_MVK_macos_surface
+void deepcopy_VkMacOSSurfaceCreateInfoMVK(
+    Pool* pool,
+    const VkMacOSSurfaceCreateInfoMVK* from,
+    VkMacOSSurfaceCreateInfoMVK* to);
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void deepcopy_VkDebugUtilsObjectNameInfoEXT(
+    Pool* pool,
+    const VkDebugUtilsObjectNameInfoEXT* from,
+    VkDebugUtilsObjectNameInfoEXT* to);
+
+void deepcopy_VkDebugUtilsObjectTagInfoEXT(
+    Pool* pool,
+    const VkDebugUtilsObjectTagInfoEXT* from,
+    VkDebugUtilsObjectTagInfoEXT* to);
+
+void deepcopy_VkDebugUtilsLabelEXT(
+    Pool* pool,
+    const VkDebugUtilsLabelEXT* from,
+    VkDebugUtilsLabelEXT* to);
+
+void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(
+    Pool* pool,
+    const VkDebugUtilsMessengerCallbackDataEXT* from,
+    VkDebugUtilsMessengerCallbackDataEXT* to);
+
+void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
+    Pool* pool,
+    const VkDebugUtilsMessengerCreateInfoEXT* from,
+    VkDebugUtilsMessengerCreateInfoEXT* to);
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void deepcopy_VkAndroidHardwareBufferUsageANDROID(
+    Pool* pool,
+    const VkAndroidHardwareBufferUsageANDROID* from,
+    VkAndroidHardwareBufferUsageANDROID* to);
+
+void deepcopy_VkAndroidHardwareBufferPropertiesANDROID(
+    Pool* pool,
+    const VkAndroidHardwareBufferPropertiesANDROID* from,
+    VkAndroidHardwareBufferPropertiesANDROID* to);
+
+void deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
+    Pool* pool,
+    const VkAndroidHardwareBufferFormatPropertiesANDROID* from,
+    VkAndroidHardwareBufferFormatPropertiesANDROID* to);
+
+void deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
+    Pool* pool,
+    const VkImportAndroidHardwareBufferInfoANDROID* from,
+    VkImportAndroidHardwareBufferInfoANDROID* to);
+
+void deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+    Pool* pool,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* from,
+    VkMemoryGetAndroidHardwareBufferInfoANDROID* to);
+
+void deepcopy_VkExternalFormatANDROID(
+    Pool* pool,
+    const VkExternalFormatANDROID* from,
+    VkExternalFormatANDROID* to);
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void deepcopy_VkSamplerReductionModeCreateInfoEXT(
+    Pool* pool,
+    const VkSamplerReductionModeCreateInfoEXT* from,
+    VkSamplerReductionModeCreateInfoEXT* to);
+
+void deepcopy_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* from,
+    VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* to);
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void deepcopy_VkSampleLocationEXT(
+    Pool* pool,
+    const VkSampleLocationEXT* from,
+    VkSampleLocationEXT* to);
+
+void deepcopy_VkSampleLocationsInfoEXT(
+    Pool* pool,
+    const VkSampleLocationsInfoEXT* from,
+    VkSampleLocationsInfoEXT* to);
+
+void deepcopy_VkAttachmentSampleLocationsEXT(
+    Pool* pool,
+    const VkAttachmentSampleLocationsEXT* from,
+    VkAttachmentSampleLocationsEXT* to);
+
+void deepcopy_VkSubpassSampleLocationsEXT(
+    Pool* pool,
+    const VkSubpassSampleLocationsEXT* from,
+    VkSubpassSampleLocationsEXT* to);
+
+void deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
+    Pool* pool,
+    const VkRenderPassSampleLocationsBeginInfoEXT* from,
+    VkRenderPassSampleLocationsBeginInfoEXT* to);
+
+void deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
+    Pool* pool,
+    const VkPipelineSampleLocationsStateCreateInfoEXT* from,
+    VkPipelineSampleLocationsStateCreateInfoEXT* to);
+
+void deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceSampleLocationsPropertiesEXT* from,
+    VkPhysicalDeviceSampleLocationsPropertiesEXT* to);
+
+void deepcopy_VkMultisamplePropertiesEXT(
+    Pool* pool,
+    const VkMultisamplePropertiesEXT* from,
+    VkMultisamplePropertiesEXT* to);
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* from,
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* from,
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to);
+
+void deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+    Pool* pool,
+    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* from,
+    VkPipelineColorBlendAdvancedStateCreateInfoEXT* to);
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
+    Pool* pool,
+    const VkPipelineCoverageToColorStateCreateInfoNV* from,
+    VkPipelineCoverageToColorStateCreateInfoNV* to);
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
+    Pool* pool,
+    const VkPipelineCoverageModulationStateCreateInfoNV* from,
+    VkPipelineCoverageModulationStateCreateInfoNV* to);
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void deepcopy_VkValidationCacheCreateInfoEXT(
+    Pool* pool,
+    const VkValidationCacheCreateInfoEXT* from,
+    VkValidationCacheCreateInfoEXT* to);
+
+void deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
+    Pool* pool,
+    const VkShaderModuleValidationCacheCreateInfoEXT* from,
+    VkShaderModuleValidationCacheCreateInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+    Pool* pool,
+    const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* from,
+    VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* to);
+
+void deepcopy_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* from,
+    VkPhysicalDeviceDescriptorIndexingFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* from,
+    VkPhysicalDeviceDescriptorIndexingPropertiesEXT* to);
+
+void deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+    Pool* pool,
+    const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* from,
+    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* to);
+
+void deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+    Pool* pool,
+    const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* from,
+    VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* to);
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+    Pool* pool,
+    const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
+    VkDeviceQueueGlobalPriorityCreateInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void deepcopy_VkImportMemoryHostPointerInfoEXT(
+    Pool* pool,
+    const VkImportMemoryHostPointerInfoEXT* from,
+    VkImportMemoryHostPointerInfoEXT* to);
+
+void deepcopy_VkMemoryHostPointerPropertiesEXT(
+    Pool* pool,
+    const VkMemoryHostPointerPropertiesEXT* from,
+    VkMemoryHostPointerPropertiesEXT* to);
+
+void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to);
+
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
+    Pool* pool,
+    const VkPhysicalDeviceShaderCorePropertiesAMD* from,
+    VkPhysicalDeviceShaderCorePropertiesAMD* to);
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    Pool* pool,
+    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to);
+
+void deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
+    Pool* pool,
+    const VkVertexInputBindingDivisorDescriptionEXT* from,
+    VkVertexInputBindingDivisorDescriptionEXT* to);
+
+void deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+    Pool* pool,
+    const VkPipelineVertexInputDivisorStateCreateInfoEXT* from,
+    VkPipelineVertexInputDivisorStateCreateInfoEXT* to);
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void deepcopy_VkQueueFamilyCheckpointPropertiesNV(
+    Pool* pool,
+    const VkQueueFamilyCheckpointPropertiesNV* from,
+    VkQueueFamilyCheckpointPropertiesNV* to);
+
+void deepcopy_VkCheckpointDataNV(
+    Pool* pool,
+    const VkCheckpointDataNV* from,
+    VkCheckpointDataNV* to);
+
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
new file mode 100644
index 0000000..410ea7f
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -0,0 +1,826 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_extension_structs_guest
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "goldfish_vk_extension_structs_guest.h"
+
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+#endif
+#ifdef VK_VERSION_1_1
+#endif
+#ifdef VK_KHR_surface
+#endif
+#ifdef VK_KHR_swapchain
+#endif
+#ifdef VK_KHR_display
+#endif
+#ifdef VK_KHR_display_swapchain
+#endif
+#ifdef VK_KHR_xlib_surface
+#endif
+#ifdef VK_KHR_xcb_surface
+#endif
+#ifdef VK_KHR_wayland_surface
+#endif
+#ifdef VK_KHR_mir_surface
+#endif
+#ifdef VK_KHR_android_surface
+#endif
+#ifdef VK_KHR_win32_surface
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+#endif
+#ifdef VK_KHR_external_memory_fd
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+#endif
+#ifdef VK_KHR_push_descriptor
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+#endif
+#ifdef VK_KHR_shared_presentable_image
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+#endif
+#ifdef VK_KHR_external_fence_fd
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+#endif
+#ifdef VK_EXT_debug_report
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+#endif
+#ifdef VK_NVX_device_generated_commands
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+#endif
+#ifdef VK_EXT_display_control
+#endif
+#ifdef VK_GOOGLE_display_timing
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+#endif
+#ifdef VK_MVK_ios_surface
+#endif
+#ifdef VK_MVK_macos_surface
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+#endif
+uint32_t goldfish_vk_struct_type(
+    const void* structExtension)
+{
+    const uint32_t asStructType = *(reinterpret_cast<const uint32_t*>(structExtension));
+    return asStructType;
+}
+
+size_t goldfish_vk_extension_struct_size(
+    const void* structExtension)
+{
+    if (!structExtension)
+    {
+        return (size_t)0;
+    }
+    uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
+    switch(structType)
+    {
+#ifdef VK_VERSION_1_1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+        {
+            return sizeof(VkPhysicalDeviceSubgroupProperties);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+        {
+            return sizeof(VkPhysicalDevice16BitStorageFeatures);
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+        {
+            return sizeof(VkMemoryDedicatedRequirements);
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+        {
+            return sizeof(VkMemoryDedicatedAllocateInfo);
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+        {
+            return sizeof(VkMemoryAllocateFlagsInfo);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+        {
+            return sizeof(VkDeviceGroupRenderPassBeginInfo);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+        {
+            return sizeof(VkDeviceGroupCommandBufferBeginInfo);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+        {
+            return sizeof(VkDeviceGroupSubmitInfo);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+        {
+            return sizeof(VkDeviceGroupBindSparseInfo);
+        }
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+        {
+            return sizeof(VkBindBufferMemoryDeviceGroupInfo);
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+        {
+            return sizeof(VkBindImageMemoryDeviceGroupInfo);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+        {
+            return sizeof(VkDeviceGroupDeviceCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+        {
+            return sizeof(VkPhysicalDeviceFeatures2);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+        {
+            return sizeof(VkPhysicalDevicePointClippingProperties);
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+        {
+            return sizeof(VkRenderPassInputAttachmentAspectCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+        {
+            return sizeof(VkImageViewUsageCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+        {
+            return sizeof(VkPipelineTessellationDomainOriginStateCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+        {
+            return sizeof(VkRenderPassMultiviewCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+        {
+            return sizeof(VkPhysicalDeviceMultiviewFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+        {
+            return sizeof(VkPhysicalDeviceMultiviewProperties);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
+        {
+            return sizeof(VkPhysicalDeviceVariablePointerFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+        {
+            return sizeof(VkPhysicalDeviceProtectedMemoryFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+        {
+            return sizeof(VkPhysicalDeviceProtectedMemoryProperties);
+        }
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+        {
+            return sizeof(VkProtectedSubmitInfo);
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+        {
+            return sizeof(VkSamplerYcbcrConversionInfo);
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+        {
+            return sizeof(VkBindImagePlaneMemoryInfo);
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+        {
+            return sizeof(VkImagePlaneMemoryRequirementsInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+        {
+            return sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures);
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+        {
+            return sizeof(VkSamplerYcbcrConversionImageFormatProperties);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+        {
+            return sizeof(VkPhysicalDeviceExternalImageFormatInfo);
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+        {
+            return sizeof(VkExternalImageFormatProperties);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+        {
+            return sizeof(VkPhysicalDeviceIDProperties);
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+        {
+            return sizeof(VkExternalMemoryImageCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+        {
+            return sizeof(VkExternalMemoryBufferCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+        {
+            return sizeof(VkExportMemoryAllocateInfo);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+        {
+            return sizeof(VkExportFenceCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+        {
+            return sizeof(VkExportSemaphoreCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+        {
+            return sizeof(VkPhysicalDeviceMaintenance3Properties);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
+        {
+            return sizeof(VkPhysicalDeviceShaderDrawParameterFeatures);
+        }
+#endif
+#ifdef VK_KHR_swapchain
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+        {
+            return sizeof(VkImageSwapchainCreateInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+        {
+            return sizeof(VkBindImageMemorySwapchainInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+        {
+            return sizeof(VkDeviceGroupPresentInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+        {
+            return sizeof(VkDeviceGroupSwapchainCreateInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_display_swapchain
+        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+        {
+            return sizeof(VkDisplayPresentInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_external_memory_win32
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            return sizeof(VkImportMemoryWin32HandleInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            return sizeof(VkExportMemoryWin32HandleInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_external_memory_fd
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+        {
+            return sizeof(VkImportMemoryFdInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+        {
+            return sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+        {
+            return sizeof(VkExportSemaphoreWin32HandleInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+        {
+            return sizeof(VkD3D12FenceSubmitInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_push_descriptor
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+        {
+            return sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR);
+        }
+#endif
+#ifdef VK_KHR_incremental_present
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+        {
+            return sizeof(VkPresentRegionsKHR);
+        }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+        {
+            return sizeof(VkSharedPresentSurfaceCapabilitiesKHR);
+        }
+#endif
+#ifdef VK_KHR_external_fence_win32
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+        {
+            return sizeof(VkExportFenceWin32HandleInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_image_format_list
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+        {
+            return sizeof(VkImageFormatListCreateInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_8bit_storage
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+        {
+            return sizeof(VkPhysicalDevice8BitStorageFeaturesKHR);
+        }
+#endif
+#ifdef VK_ANDROID_native_buffer
+        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
+        {
+            return sizeof(VkNativeBufferANDROID);
+        }
+#endif
+#ifdef VK_EXT_debug_report
+        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+        {
+            return sizeof(VkDebugReportCallbackCreateInfoEXT);
+        }
+#endif
+#ifdef VK_AMD_rasterization_order
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+        {
+            return sizeof(VkPipelineRasterizationStateRasterizationOrderAMD);
+        }
+#endif
+#ifdef VK_NV_dedicated_allocation
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+        {
+            return sizeof(VkDedicatedAllocationImageCreateInfoNV);
+        }
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+        {
+            return sizeof(VkDedicatedAllocationBufferCreateInfoNV);
+        }
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+        {
+            return sizeof(VkDedicatedAllocationMemoryAllocateInfoNV);
+        }
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+        {
+            return sizeof(VkTextureLODGatherFormatPropertiesAMD);
+        }
+#endif
+#ifdef VK_NV_external_memory
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+        {
+            return sizeof(VkExternalMemoryImageCreateInfoNV);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+        {
+            return sizeof(VkExportMemoryAllocateInfoNV);
+        }
+#endif
+#ifdef VK_NV_external_memory_win32
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+        {
+            return sizeof(VkImportMemoryWin32HandleInfoNV);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+        {
+            return sizeof(VkExportMemoryWin32HandleInfoNV);
+        }
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+        {
+            return sizeof(VkWin32KeyedMutexAcquireReleaseInfoNV);
+        }
+#endif
+#ifdef VK_EXT_validation_flags
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+        {
+            return sizeof(VkValidationFlagsEXT);
+        }
+#endif
+#ifdef VK_EXT_conditional_rendering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+        {
+            return sizeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT);
+        }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+        {
+            return sizeof(VkPipelineViewportWScalingStateCreateInfoNV);
+        }
+#endif
+#ifdef VK_EXT_display_control
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+        {
+            return sizeof(VkSwapchainCounterCreateInfoEXT);
+        }
+#endif
+#ifdef VK_GOOGLE_display_timing
+        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+        {
+            return sizeof(VkPresentTimesInfoGOOGLE);
+        }
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+        {
+            return sizeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX);
+        }
+#endif
+#ifdef VK_NV_viewport_swizzle
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+        {
+            return sizeof(VkPipelineViewportSwizzleStateCreateInfoNV);
+        }
+#endif
+#ifdef VK_EXT_discard_rectangles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+        {
+            return sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT);
+        }
+#endif
+#ifdef VK_EXT_conservative_rasterization
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+        {
+            return sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT);
+        }
+#endif
+#ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+        {
+            return sizeof(VkDebugUtilsMessengerCreateInfoEXT);
+        }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+        {
+            return sizeof(VkAndroidHardwareBufferUsageANDROID);
+        }
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+        {
+            return sizeof(VkAndroidHardwareBufferFormatPropertiesANDROID);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+        {
+            return sizeof(VkImportAndroidHardwareBufferInfoANDROID);
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+        {
+            return sizeof(VkExternalFormatANDROID);
+        }
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+        {
+            return sizeof(VkSamplerReductionModeCreateInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT);
+        }
+#endif
+#ifdef VK_EXT_sample_locations
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+        {
+            return sizeof(VkSampleLocationsInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+        {
+            return sizeof(VkRenderPassSampleLocationsBeginInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+        {
+            return sizeof(VkPipelineSampleLocationsStateCreateInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT);
+        }
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+        {
+            return sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT);
+        }
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+        {
+            return sizeof(VkPipelineCoverageToColorStateCreateInfoNV);
+        }
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+        {
+            return sizeof(VkPipelineCoverageModulationStateCreateInfoNV);
+        }
+#endif
+#ifdef VK_EXT_validation_cache
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+        {
+            return sizeof(VkShaderModuleValidationCacheCreateInfoEXT);
+        }
+#endif
+#ifdef VK_EXT_descriptor_indexing
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+        {
+            return sizeof(VkDescriptorSetLayoutBindingFlagsCreateInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceDescriptorIndexingPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+        {
+            return sizeof(VkDescriptorSetVariableDescriptorCountAllocateInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+        {
+            return sizeof(VkDescriptorSetVariableDescriptorCountLayoutSupportEXT);
+        }
+#endif
+#ifdef VK_EXT_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
+        {
+            return sizeof(VkDeviceQueueGlobalPriorityCreateInfoEXT);
+        }
+#endif
+#ifdef VK_EXT_external_memory_host
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+        {
+            return sizeof(VkImportMemoryHostPointerInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT);
+        }
+#endif
+#ifdef VK_AMD_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+        {
+            return sizeof(VkPhysicalDeviceShaderCorePropertiesAMD);
+        }
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+        {
+            return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+        {
+            return sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT);
+        }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+        {
+            return sizeof(VkQueueFamilyCheckpointPropertiesNV);
+        }
+#endif
+        default:
+        {
+            return (size_t)0;
+        }
+    }
+}
+
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
new file mode 100644
index 0000000..6c5a04c
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
@@ -0,0 +1,295 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_extension_structs_guest
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "vk_platform_compat.h"
+#include "goldfish_vk_private_defs.h"
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+uint32_t goldfish_vk_struct_type(
+    const void* structExtension);
+
+size_t goldfish_vk_extension_struct_size(
+    const void* structExtension);
+
+#ifdef VK_VERSION_1_0
+#endif
+#ifdef VK_VERSION_1_1
+#endif
+#ifdef VK_KHR_surface
+#endif
+#ifdef VK_KHR_swapchain
+#endif
+#ifdef VK_KHR_display
+#endif
+#ifdef VK_KHR_display_swapchain
+#endif
+#ifdef VK_KHR_xlib_surface
+#endif
+#ifdef VK_KHR_xcb_surface
+#endif
+#ifdef VK_KHR_wayland_surface
+#endif
+#ifdef VK_KHR_mir_surface
+#endif
+#ifdef VK_KHR_android_surface
+#endif
+#ifdef VK_KHR_win32_surface
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+#endif
+#ifdef VK_KHR_external_memory_fd
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+#endif
+#ifdef VK_KHR_push_descriptor
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+#endif
+#ifdef VK_KHR_shared_presentable_image
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+#endif
+#ifdef VK_KHR_external_fence_fd
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+#endif
+#ifdef VK_EXT_debug_report
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+#endif
+#ifdef VK_NVX_device_generated_commands
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+#endif
+#ifdef VK_EXT_display_control
+#endif
+#ifdef VK_GOOGLE_display_timing
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+#endif
+#ifdef VK_MVK_ios_surface
+#endif
+#ifdef VK_MVK_macos_surface
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
new file mode 100644
index 0000000..e6ab090
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
@@ -0,0 +1,5371 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_handlemap_guest
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "goldfish_vk_handlemap_guest.h"
+
+
+#include "goldfish_vk_extension_structs_guest.h"
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+void handlemap_extension_struct(
+    VulkanHandleMapping* handlemap,
+    void* structExtension_out);
+
+#ifdef VK_VERSION_1_0
+void handlemap_VkApplicationInfo(
+    VulkanHandleMapping* handlemap,
+    VkApplicationInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkInstanceCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkInstanceCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pApplicationInfo)
+    {
+        handlemap_VkApplicationInfo(handlemap, (VkApplicationInfo*)(toMap->pApplicationInfo));
+    }
+}
+
+void handlemap_VkAllocationCallbacks(
+    VulkanHandleMapping* handlemap,
+    VkAllocationCallbacks* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceFeatures* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkFormatProperties(
+    VulkanHandleMapping* handlemap,
+    VkFormatProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkExtent3D(
+    VulkanHandleMapping* handlemap,
+    VkExtent3D* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkImageFormatProperties(
+    VulkanHandleMapping* handlemap,
+    VkImageFormatProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->maxExtent));
+}
+
+void handlemap_VkPhysicalDeviceLimits(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceLimits* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceSparseProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSparseProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkPhysicalDeviceLimits(handlemap, (VkPhysicalDeviceLimits*)(&toMap->limits));
+    handlemap_VkPhysicalDeviceSparseProperties(handlemap, (VkPhysicalDeviceSparseProperties*)(&toMap->sparseProperties));
+}
+
+void handlemap_VkQueueFamilyProperties(
+    VulkanHandleMapping* handlemap,
+    VkQueueFamilyProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->minImageTransferGranularity));
+}
+
+void handlemap_VkMemoryType(
+    VulkanHandleMapping* handlemap,
+    VkMemoryType* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkMemoryHeap(
+    VulkanHandleMapping* handlemap,
+    VkMemoryHeap* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceMemoryProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMemoryProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
+    {
+        handlemap_VkMemoryType(handlemap, (VkMemoryType*)(toMap->memoryTypes + i));
+    }
+    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
+    {
+        handlemap_VkMemoryHeap(handlemap, (VkMemoryHeap*)(toMap->memoryHeaps + i));
+    }
+}
+
+void handlemap_VkDeviceQueueCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceQueueCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pQueueCreateInfos)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->queueCreateInfoCount; ++i)
+        {
+            handlemap_VkDeviceQueueCreateInfo(handlemap, (VkDeviceQueueCreateInfo*)(toMap->pQueueCreateInfos + i));
+        }
+    }
+    if (toMap->pEnabledFeatures)
+    {
+        handlemap_VkPhysicalDeviceFeatures(handlemap, (VkPhysicalDeviceFeatures*)(toMap->pEnabledFeatures));
+    }
+}
+
+void handlemap_VkExtensionProperties(
+    VulkanHandleMapping* handlemap,
+    VkExtensionProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkLayerProperties(
+    VulkanHandleMapping* handlemap,
+    VkLayerProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkSubmitInfo(
+    VulkanHandleMapping* handlemap,
+    VkSubmitInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pWaitSemaphores)
+    {
+        handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
+    }
+    if (toMap->pCommandBuffers)
+    {
+        handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)toMap->pCommandBuffers, toMap->commandBufferCount);
+    }
+    if (toMap->pSignalSemaphores)
+    {
+        handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores, toMap->signalSemaphoreCount);
+    }
+}
+
+void handlemap_VkMemoryAllocateInfo(
+    VulkanHandleMapping* handlemap,
+    VkMemoryAllocateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMappedMemoryRange(
+    VulkanHandleMapping* handlemap,
+    VkMappedMemoryRange* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkMemoryRequirements(
+    VulkanHandleMapping* handlemap,
+    VkMemoryRequirements* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkSparseImageFormatProperties(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageFormatProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageGranularity));
+}
+
+void handlemap_VkSparseImageMemoryRequirements(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageMemoryRequirements* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkSparseImageFormatProperties(handlemap, (VkSparseImageFormatProperties*)(&toMap->formatProperties));
+}
+
+void handlemap_VkSparseMemoryBind(
+    VulkanHandleMapping* handlemap,
+    VkSparseMemoryBind* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkSparseBufferMemoryBindInfo(
+    VulkanHandleMapping* handlemap,
+    VkSparseBufferMemoryBindInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+    if (toMap->pBinds)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
+        {
+            handlemap_VkSparseMemoryBind(handlemap, (VkSparseMemoryBind*)(toMap->pBinds + i));
+        }
+    }
+}
+
+void handlemap_VkSparseImageOpaqueMemoryBindInfo(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageOpaqueMemoryBindInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+    if (toMap->pBinds)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
+        {
+            handlemap_VkSparseMemoryBind(handlemap, (VkSparseMemoryBind*)(toMap->pBinds + i));
+        }
+    }
+}
+
+void handlemap_VkImageSubresource(
+    VulkanHandleMapping* handlemap,
+    VkImageSubresource* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkOffset3D(
+    VulkanHandleMapping* handlemap,
+    VkOffset3D* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkSparseImageMemoryBind(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageMemoryBind* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkImageSubresource(handlemap, (VkImageSubresource*)(&toMap->subresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->offset));
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkSparseImageMemoryBindInfo(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageMemoryBindInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+    if (toMap->pBinds)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
+        {
+            handlemap_VkSparseImageMemoryBind(handlemap, (VkSparseImageMemoryBind*)(toMap->pBinds + i));
+        }
+    }
+}
+
+void handlemap_VkBindSparseInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindSparseInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pWaitSemaphores)
+    {
+        handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
+    }
+    if (toMap->pBufferBinds)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->bufferBindCount; ++i)
+        {
+            handlemap_VkSparseBufferMemoryBindInfo(handlemap, (VkSparseBufferMemoryBindInfo*)(toMap->pBufferBinds + i));
+        }
+    }
+    if (toMap->pImageOpaqueBinds)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->imageOpaqueBindCount; ++i)
+        {
+            handlemap_VkSparseImageOpaqueMemoryBindInfo(handlemap, (VkSparseImageOpaqueMemoryBindInfo*)(toMap->pImageOpaqueBinds + i));
+        }
+    }
+    if (toMap->pImageBinds)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->imageBindCount; ++i)
+        {
+            handlemap_VkSparseImageMemoryBindInfo(handlemap, (VkSparseImageMemoryBindInfo*)(toMap->pImageBinds + i));
+        }
+    }
+    if (toMap->pSignalSemaphores)
+    {
+        handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores, toMap->signalSemaphoreCount);
+    }
+}
+
+void handlemap_VkFenceCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkFenceCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSemaphoreCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkSemaphoreCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkEventCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkEventCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkQueryPoolCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkQueryPoolCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkBufferCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkBufferCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkBufferViewCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkBufferViewCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkImageCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkImageCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
+}
+
+void handlemap_VkSubresourceLayout(
+    VulkanHandleMapping* handlemap,
+    VkSubresourceLayout* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkComponentMapping(
+    VulkanHandleMapping* handlemap,
+    VkComponentMapping* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkImageSubresourceRange(
+    VulkanHandleMapping* handlemap,
+    VkImageSubresourceRange* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkImageViewCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkImageViewCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+    handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
+    handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
+}
+
+void handlemap_VkShaderModuleCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkShaderModuleCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineCacheCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineCacheCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSpecializationMapEntry(
+    VulkanHandleMapping* handlemap,
+    VkSpecializationMapEntry* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkSpecializationInfo(
+    VulkanHandleMapping* handlemap,
+    VkSpecializationInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pMapEntries)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->mapEntryCount; ++i)
+        {
+            handlemap_VkSpecializationMapEntry(handlemap, (VkSpecializationMapEntry*)(toMap->pMapEntries + i));
+        }
+    }
+}
+
+void handlemap_VkPipelineShaderStageCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineShaderStageCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkShaderModule((VkShaderModule*)&toMap->module);
+    if (toMap->pSpecializationInfo)
+    {
+        handlemap_VkSpecializationInfo(handlemap, (VkSpecializationInfo*)(toMap->pSpecializationInfo));
+    }
+}
+
+void handlemap_VkVertexInputBindingDescription(
+    VulkanHandleMapping* handlemap,
+    VkVertexInputBindingDescription* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkVertexInputAttributeDescription(
+    VulkanHandleMapping* handlemap,
+    VkVertexInputAttributeDescription* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPipelineVertexInputStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineVertexInputStateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pVertexBindingDescriptions)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDescriptionCount; ++i)
+        {
+            handlemap_VkVertexInputBindingDescription(handlemap, (VkVertexInputBindingDescription*)(toMap->pVertexBindingDescriptions + i));
+        }
+    }
+    if (toMap->pVertexAttributeDescriptions)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->vertexAttributeDescriptionCount; ++i)
+        {
+            handlemap_VkVertexInputAttributeDescription(handlemap, (VkVertexInputAttributeDescription*)(toMap->pVertexAttributeDescriptions + i));
+        }
+    }
+}
+
+void handlemap_VkPipelineInputAssemblyStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineInputAssemblyStateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineTessellationStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineTessellationStateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkViewport(
+    VulkanHandleMapping* handlemap,
+    VkViewport* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkOffset2D(
+    VulkanHandleMapping* handlemap,
+    VkOffset2D* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkExtent2D(
+    VulkanHandleMapping* handlemap,
+    VkExtent2D* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkRect2D(
+    VulkanHandleMapping* handlemap,
+    VkRect2D* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->offset));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->extent));
+}
+
+void handlemap_VkPipelineViewportStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineViewportStateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pViewports)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
+        {
+            handlemap_VkViewport(handlemap, (VkViewport*)(toMap->pViewports + i));
+        }
+    }
+    if (toMap->pScissors)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->scissorCount; ++i)
+        {
+            handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pScissors + i));
+        }
+    }
+}
+
+void handlemap_VkPipelineRasterizationStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineRasterizationStateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineMultisampleStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineMultisampleStateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkStencilOpState(
+    VulkanHandleMapping* handlemap,
+    VkStencilOpState* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPipelineDepthStencilStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineDepthStencilStateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkStencilOpState(handlemap, (VkStencilOpState*)(&toMap->front));
+    handlemap_VkStencilOpState(handlemap, (VkStencilOpState*)(&toMap->back));
+}
+
+void handlemap_VkPipelineColorBlendAttachmentState(
+    VulkanHandleMapping* handlemap,
+    VkPipelineColorBlendAttachmentState* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPipelineColorBlendStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineColorBlendStateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
+        {
+            handlemap_VkPipelineColorBlendAttachmentState(handlemap, (VkPipelineColorBlendAttachmentState*)(toMap->pAttachments + i));
+        }
+    }
+}
+
+void handlemap_VkPipelineDynamicStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineDynamicStateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkGraphicsPipelineCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkGraphicsPipelineCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pStages)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i)
+        {
+            handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
+        }
+    }
+    if (toMap->pVertexInputState)
+    {
+        handlemap_VkPipelineVertexInputStateCreateInfo(handlemap, (VkPipelineVertexInputStateCreateInfo*)(toMap->pVertexInputState));
+    }
+    if (toMap->pInputAssemblyState)
+    {
+        handlemap_VkPipelineInputAssemblyStateCreateInfo(handlemap, (VkPipelineInputAssemblyStateCreateInfo*)(toMap->pInputAssemblyState));
+    }
+    if (toMap->pTessellationState)
+    {
+        handlemap_VkPipelineTessellationStateCreateInfo(handlemap, (VkPipelineTessellationStateCreateInfo*)(toMap->pTessellationState));
+    }
+    if (toMap->pViewportState)
+    {
+        handlemap_VkPipelineViewportStateCreateInfo(handlemap, (VkPipelineViewportStateCreateInfo*)(toMap->pViewportState));
+    }
+    if (toMap->pRasterizationState)
+    {
+        handlemap_VkPipelineRasterizationStateCreateInfo(handlemap, (VkPipelineRasterizationStateCreateInfo*)(toMap->pRasterizationState));
+    }
+    if (toMap->pMultisampleState)
+    {
+        handlemap_VkPipelineMultisampleStateCreateInfo(handlemap, (VkPipelineMultisampleStateCreateInfo*)(toMap->pMultisampleState));
+    }
+    if (toMap->pDepthStencilState)
+    {
+        handlemap_VkPipelineDepthStencilStateCreateInfo(handlemap, (VkPipelineDepthStencilStateCreateInfo*)(toMap->pDepthStencilState));
+    }
+    if (toMap->pColorBlendState)
+    {
+        handlemap_VkPipelineColorBlendStateCreateInfo(handlemap, (VkPipelineColorBlendStateCreateInfo*)(toMap->pColorBlendState));
+    }
+    if (toMap->pDynamicState)
+    {
+        handlemap_VkPipelineDynamicStateCreateInfo(handlemap, (VkPipelineDynamicStateCreateInfo*)(toMap->pDynamicState));
+    }
+    handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
+    handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
+    handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
+}
+
+void handlemap_VkComputePipelineCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkComputePipelineCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(&toMap->stage));
+    handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
+    handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
+}
+
+void handlemap_VkPushConstantRange(
+    VulkanHandleMapping* handlemap,
+    VkPushConstantRange* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPipelineLayoutCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineLayoutCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pSetLayouts)
+    {
+        handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts, toMap->setLayoutCount);
+    }
+    if (toMap->pPushConstantRanges)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->pushConstantRangeCount; ++i)
+        {
+            handlemap_VkPushConstantRange(handlemap, (VkPushConstantRange*)(toMap->pPushConstantRanges + i));
+        }
+    }
+}
+
+void handlemap_VkSamplerCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkSamplerCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDescriptorSetLayoutBinding(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetLayoutBinding* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pImmutableSamplers)
+    {
+        handlemap->mapHandles_VkSampler((VkSampler*)toMap->pImmutableSamplers, toMap->descriptorCount);
+    }
+}
+
+void handlemap_VkDescriptorSetLayoutCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetLayoutCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pBindings)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->bindingCount; ++i)
+        {
+            handlemap_VkDescriptorSetLayoutBinding(handlemap, (VkDescriptorSetLayoutBinding*)(toMap->pBindings + i));
+        }
+    }
+}
+
+void handlemap_VkDescriptorPoolSize(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorPoolSize* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkDescriptorPoolCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorPoolCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pPoolSizes)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->poolSizeCount; ++i)
+        {
+            handlemap_VkDescriptorPoolSize(handlemap, (VkDescriptorPoolSize*)(toMap->pPoolSizes + i));
+        }
+    }
+}
+
+void handlemap_VkDescriptorSetAllocateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetAllocateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDescriptorPool((VkDescriptorPool*)&toMap->descriptorPool);
+    if (toMap->pSetLayouts)
+    {
+        handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts, toMap->descriptorSetCount);
+    }
+}
+
+void handlemap_VkDescriptorImageInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorImageInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkSampler((VkSampler*)&toMap->sampler);
+    handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
+}
+
+void handlemap_VkDescriptorBufferInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorBufferInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkWriteDescriptorSet(
+    VulkanHandleMapping* handlemap,
+    VkWriteDescriptorSet* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->dstSet);
+    if (toMap->pImageInfo)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i)
+        {
+            handlemap_VkDescriptorImageInfo(handlemap, (VkDescriptorImageInfo*)(toMap->pImageInfo + i));
+        }
+    }
+    if (toMap->pBufferInfo)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i)
+        {
+            handlemap_VkDescriptorBufferInfo(handlemap, (VkDescriptorBufferInfo*)(toMap->pBufferInfo + i));
+        }
+    }
+    if (toMap->pTexelBufferView)
+    {
+        handlemap->mapHandles_VkBufferView((VkBufferView*)toMap->pTexelBufferView, toMap->descriptorCount);
+    }
+}
+
+void handlemap_VkCopyDescriptorSet(
+    VulkanHandleMapping* handlemap,
+    VkCopyDescriptorSet* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->srcSet);
+    handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->dstSet);
+}
+
+void handlemap_VkFramebufferCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkFramebufferCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
+    if (toMap->pAttachments)
+    {
+        handlemap->mapHandles_VkImageView((VkImageView*)toMap->pAttachments, toMap->attachmentCount);
+    }
+}
+
+void handlemap_VkAttachmentDescription(
+    VulkanHandleMapping* handlemap,
+    VkAttachmentDescription* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkAttachmentReference(
+    VulkanHandleMapping* handlemap,
+    VkAttachmentReference* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkSubpassDescription(
+    VulkanHandleMapping* handlemap,
+    VkSubpassDescription* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pInputAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i)
+        {
+            handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pInputAttachments + i));
+        }
+    }
+    if (toMap->pColorAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
+        {
+            handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pColorAttachments + i));
+        }
+    }
+    if (toMap->pResolveAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
+        {
+            handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pResolveAttachments + i));
+        }
+    }
+    if (toMap->pDepthStencilAttachment)
+    {
+        handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pDepthStencilAttachment));
+    }
+}
+
+void handlemap_VkSubpassDependency(
+    VulkanHandleMapping* handlemap,
+    VkSubpassDependency* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkRenderPassCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
+        {
+            handlemap_VkAttachmentDescription(handlemap, (VkAttachmentDescription*)(toMap->pAttachments + i));
+        }
+    }
+    if (toMap->pSubpasses)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i)
+        {
+            handlemap_VkSubpassDescription(handlemap, (VkSubpassDescription*)(toMap->pSubpasses + i));
+        }
+    }
+    if (toMap->pDependencies)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i)
+        {
+            handlemap_VkSubpassDependency(handlemap, (VkSubpassDependency*)(toMap->pDependencies + i));
+        }
+    }
+}
+
+void handlemap_VkCommandPoolCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkCommandPoolCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkCommandBufferAllocateInfo(
+    VulkanHandleMapping* handlemap,
+    VkCommandBufferAllocateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkCommandPool((VkCommandPool*)&toMap->commandPool);
+}
+
+void handlemap_VkCommandBufferInheritanceInfo(
+    VulkanHandleMapping* handlemap,
+    VkCommandBufferInheritanceInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
+    handlemap->mapHandles_VkFramebuffer((VkFramebuffer*)&toMap->framebuffer);
+}
+
+void handlemap_VkCommandBufferBeginInfo(
+    VulkanHandleMapping* handlemap,
+    VkCommandBufferBeginInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pInheritanceInfo)
+    {
+        handlemap_VkCommandBufferInheritanceInfo(handlemap, (VkCommandBufferInheritanceInfo*)(toMap->pInheritanceInfo));
+    }
+}
+
+void handlemap_VkBufferCopy(
+    VulkanHandleMapping* handlemap,
+    VkBufferCopy* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkImageSubresourceLayers(
+    VulkanHandleMapping* handlemap,
+    VkImageSubresourceLayers* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkImageCopy(
+    VulkanHandleMapping* handlemap,
+    VkImageCopy* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
+    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
+}
+
+void handlemap_VkImageBlit(
+    VulkanHandleMapping* handlemap,
+    VkImageBlit* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i)
+    {
+        handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->srcOffsets + i));
+    }
+    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i)
+    {
+        handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->dstOffsets + i));
+    }
+}
+
+void handlemap_VkBufferImageCopy(
+    VulkanHandleMapping* handlemap,
+    VkBufferImageCopy* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->imageSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
+}
+
+void handlemap_VkClearColorValue(
+    VulkanHandleMapping* handlemap,
+    VkClearColorValue* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkClearDepthStencilValue(
+    VulkanHandleMapping* handlemap,
+    VkClearDepthStencilValue* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkClearValue(
+    VulkanHandleMapping* handlemap,
+    VkClearValue* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkClearColorValue(handlemap, (VkClearColorValue*)(&toMap->color));
+    handlemap_VkClearDepthStencilValue(handlemap, (VkClearDepthStencilValue*)(&toMap->depthStencil));
+}
+
+void handlemap_VkClearAttachment(
+    VulkanHandleMapping* handlemap,
+    VkClearAttachment* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkClearValue(handlemap, (VkClearValue*)(&toMap->clearValue));
+}
+
+void handlemap_VkClearRect(
+    VulkanHandleMapping* handlemap,
+    VkClearRect* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->rect));
+}
+
+void handlemap_VkImageResolve(
+    VulkanHandleMapping* handlemap,
+    VkImageResolve* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
+    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
+}
+
+void handlemap_VkMemoryBarrier(
+    VulkanHandleMapping* handlemap,
+    VkMemoryBarrier* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkBufferMemoryBarrier(
+    VulkanHandleMapping* handlemap,
+    VkBufferMemoryBarrier* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkImageMemoryBarrier(
+    VulkanHandleMapping* handlemap,
+    VkImageMemoryBarrier* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+    handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
+}
+
+void handlemap_VkRenderPassBeginInfo(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassBeginInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
+    handlemap->mapHandles_VkFramebuffer((VkFramebuffer*)&toMap->framebuffer);
+    handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->renderArea));
+    if (toMap->pClearValues)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->clearValueCount; ++i)
+        {
+            handlemap_VkClearValue(handlemap, (VkClearValue*)(toMap->pClearValues + i));
+        }
+    }
+}
+
+void handlemap_VkDispatchIndirectCommand(
+    VulkanHandleMapping* handlemap,
+    VkDispatchIndirectCommand* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkDrawIndexedIndirectCommand(
+    VulkanHandleMapping* handlemap,
+    VkDrawIndexedIndirectCommand* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkDrawIndirectCommand(
+    VulkanHandleMapping* handlemap,
+    VkDrawIndirectCommand* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkBaseOutStructure(
+    VulkanHandleMapping* handlemap,
+    VkBaseOutStructure* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkBaseInStructure(
+    VulkanHandleMapping* handlemap,
+    VkBaseInStructure* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_VERSION_1_1
+void handlemap_VkPhysicalDeviceSubgroupProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSubgroupProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkBindBufferMemoryInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindBufferMemoryInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkBindImageMemoryInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindImageMemoryInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkPhysicalDevice16BitStorageFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDevice16BitStorageFeatures* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMemoryDedicatedRequirements(
+    VulkanHandleMapping* handlemap,
+    VkMemoryDedicatedRequirements* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMemoryDedicatedAllocateInfo(
+    VulkanHandleMapping* handlemap,
+    VkMemoryDedicatedAllocateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkMemoryAllocateFlagsInfo(
+    VulkanHandleMapping* handlemap,
+    VkMemoryAllocateFlagsInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceGroupRenderPassBeginInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupRenderPassBeginInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pDeviceRenderAreas)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->deviceRenderAreaCount; ++i)
+        {
+            handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pDeviceRenderAreas + i));
+        }
+    }
+}
+
+void handlemap_VkDeviceGroupCommandBufferBeginInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupCommandBufferBeginInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceGroupSubmitInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupSubmitInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceGroupBindSparseInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupBindSparseInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkBindBufferMemoryDeviceGroupInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindBufferMemoryDeviceGroupInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkBindImageMemoryDeviceGroupInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindImageMemoryDeviceGroupInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pSplitInstanceBindRegions)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->splitInstanceBindRegionCount; ++i)
+        {
+            handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pSplitInstanceBindRegions + i));
+        }
+    }
+}
+
+void handlemap_VkPhysicalDeviceGroupProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceGroupProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
+}
+
+void handlemap_VkDeviceGroupDeviceCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupDeviceCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pPhysicalDevices)
+    {
+        handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->pPhysicalDevices, toMap->physicalDeviceCount);
+    }
+}
+
+void handlemap_VkBufferMemoryRequirementsInfo2(
+    VulkanHandleMapping* handlemap,
+    VkBufferMemoryRequirementsInfo2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkImageMemoryRequirementsInfo2(
+    VulkanHandleMapping* handlemap,
+    VkImageMemoryRequirementsInfo2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+}
+
+void handlemap_VkImageSparseMemoryRequirementsInfo2(
+    VulkanHandleMapping* handlemap,
+    VkImageSparseMemoryRequirementsInfo2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+}
+
+void handlemap_VkMemoryRequirements2(
+    VulkanHandleMapping* handlemap,
+    VkMemoryRequirements2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkMemoryRequirements(handlemap, (VkMemoryRequirements*)(&toMap->memoryRequirements));
+}
+
+void handlemap_VkSparseImageMemoryRequirements2(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageMemoryRequirements2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkSparseImageMemoryRequirements(handlemap, (VkSparseImageMemoryRequirements*)(&toMap->memoryRequirements));
+}
+
+void handlemap_VkPhysicalDeviceFeatures2(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceFeatures2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkPhysicalDeviceFeatures(handlemap, (VkPhysicalDeviceFeatures*)(&toMap->features));
+}
+
+void handlemap_VkPhysicalDeviceProperties2(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceProperties2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkPhysicalDeviceProperties(handlemap, (VkPhysicalDeviceProperties*)(&toMap->properties));
+}
+
+void handlemap_VkFormatProperties2(
+    VulkanHandleMapping* handlemap,
+    VkFormatProperties2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkFormatProperties(handlemap, (VkFormatProperties*)(&toMap->formatProperties));
+}
+
+void handlemap_VkImageFormatProperties2(
+    VulkanHandleMapping* handlemap,
+    VkImageFormatProperties2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkImageFormatProperties(handlemap, (VkImageFormatProperties*)(&toMap->imageFormatProperties));
+}
+
+void handlemap_VkPhysicalDeviceImageFormatInfo2(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceImageFormatInfo2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkQueueFamilyProperties2(
+    VulkanHandleMapping* handlemap,
+    VkQueueFamilyProperties2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkQueueFamilyProperties(handlemap, (VkQueueFamilyProperties*)(&toMap->queueFamilyProperties));
+}
+
+void handlemap_VkPhysicalDeviceMemoryProperties2(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMemoryProperties2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkPhysicalDeviceMemoryProperties(handlemap, (VkPhysicalDeviceMemoryProperties*)(&toMap->memoryProperties));
+}
+
+void handlemap_VkSparseImageFormatProperties2(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageFormatProperties2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkSparseImageFormatProperties(handlemap, (VkSparseImageFormatProperties*)(&toMap->properties));
+}
+
+void handlemap_VkPhysicalDeviceSparseImageFormatInfo2(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSparseImageFormatInfo2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDevicePointClippingProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDevicePointClippingProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkInputAttachmentAspectReference(
+    VulkanHandleMapping* handlemap,
+    VkInputAttachmentAspectReference* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkRenderPassInputAttachmentAspectCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassInputAttachmentAspectCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pAspectReferences)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->aspectReferenceCount; ++i)
+        {
+            handlemap_VkInputAttachmentAspectReference(handlemap, (VkInputAttachmentAspectReference*)(toMap->pAspectReferences + i));
+        }
+    }
+}
+
+void handlemap_VkImageViewUsageCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkImageViewUsageCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineTessellationDomainOriginStateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkRenderPassMultiviewCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassMultiviewCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceMultiviewFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMultiviewFeatures* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceMultiviewProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMultiviewProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceVariablePointerFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceVariablePointerFeatures* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceProtectedMemoryFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceProtectedMemoryFeatures* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceProtectedMemoryProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceProtectedMemoryProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceQueueInfo2(
+    VulkanHandleMapping* handlemap,
+    VkDeviceQueueInfo2* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkProtectedSubmitInfo(
+    VulkanHandleMapping* handlemap,
+    VkProtectedSubmitInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSamplerYcbcrConversionCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkSamplerYcbcrConversionCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
+}
+
+void handlemap_VkSamplerYcbcrConversionInfo(
+    VulkanHandleMapping* handlemap,
+    VkSamplerYcbcrConversionInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&toMap->conversion);
+}
+
+void handlemap_VkBindImagePlaneMemoryInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindImagePlaneMemoryInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkImagePlaneMemoryRequirementsInfo(
+    VulkanHandleMapping* handlemap,
+    VkImagePlaneMemoryRequirementsInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSamplerYcbcrConversionImageFormatProperties(
+    VulkanHandleMapping* handlemap,
+    VkSamplerYcbcrConversionImageFormatProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDescriptorUpdateTemplateEntry(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorUpdateTemplateEntry* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkDescriptorUpdateTemplateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorUpdateTemplateCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pDescriptorUpdateEntries)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->descriptorUpdateEntryCount; ++i)
+        {
+            handlemap_VkDescriptorUpdateTemplateEntry(handlemap, (VkDescriptorUpdateTemplateEntry*)(toMap->pDescriptorUpdateEntries + i));
+        }
+    }
+    handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&toMap->descriptorSetLayout);
+    handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
+}
+
+void handlemap_VkExternalMemoryProperties(
+    VulkanHandleMapping* handlemap,
+    VkExternalMemoryProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceExternalImageFormatInfo(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceExternalImageFormatInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExternalImageFormatProperties(
+    VulkanHandleMapping* handlemap,
+    VkExternalImageFormatProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExternalMemoryProperties(handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
+}
+
+void handlemap_VkPhysicalDeviceExternalBufferInfo(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceExternalBufferInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExternalBufferProperties(
+    VulkanHandleMapping* handlemap,
+    VkExternalBufferProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExternalMemoryProperties(handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
+}
+
+void handlemap_VkPhysicalDeviceIDProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceIDProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExternalMemoryImageCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkExternalMemoryImageCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExternalMemoryBufferCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkExternalMemoryBufferCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportMemoryAllocateInfo(
+    VulkanHandleMapping* handlemap,
+    VkExportMemoryAllocateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceExternalFenceInfo(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceExternalFenceInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExternalFenceProperties(
+    VulkanHandleMapping* handlemap,
+    VkExternalFenceProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportFenceCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkExportFenceCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportSemaphoreCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkExportSemaphoreCreateInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceExternalSemaphoreInfo* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExternalSemaphoreProperties(
+    VulkanHandleMapping* handlemap,
+    VkExternalSemaphoreProperties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceMaintenance3Properties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMaintenance3Properties* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDescriptorSetLayoutSupport(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetLayoutSupport* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceShaderDrawParameterFeatures* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_surface
+void handlemap_VkSurfaceCapabilitiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkSurfaceCapabilitiesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->currentExtent));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minImageExtent));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxImageExtent));
+}
+
+void handlemap_VkSurfaceFormatKHR(
+    VulkanHandleMapping* handlemap,
+    VkSurfaceFormatKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+#endif
+#ifdef VK_KHR_swapchain
+void handlemap_VkSwapchainCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkSwapchainCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&toMap->surface);
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->imageExtent));
+    handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->oldSwapchain);
+}
+
+void handlemap_VkPresentInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkPresentInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pWaitSemaphores)
+    {
+        handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
+    }
+    if (toMap->pSwapchains)
+    {
+        handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)toMap->pSwapchains, toMap->swapchainCount);
+    }
+}
+
+void handlemap_VkImageSwapchainCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImageSwapchainCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
+}
+
+void handlemap_VkBindImageMemorySwapchainInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkBindImageMemorySwapchainInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
+}
+
+void handlemap_VkAcquireNextImageInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkAcquireNextImageInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
+    handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+    handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
+}
+
+void handlemap_VkDeviceGroupPresentCapabilitiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupPresentCapabilitiesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceGroupPresentInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupPresentInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupSwapchainCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_display
+void handlemap_VkDisplayPropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPropertiesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkDisplayKHR((VkDisplayKHR*)&toMap->display);
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->physicalDimensions));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->physicalResolution));
+}
+
+void handlemap_VkDisplayModeParametersKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayModeParametersKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->visibleRegion));
+}
+
+void handlemap_VkDisplayModePropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayModePropertiesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->displayMode);
+    handlemap_VkDisplayModeParametersKHR(handlemap, (VkDisplayModeParametersKHR*)(&toMap->parameters));
+}
+
+void handlemap_VkDisplayModeCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayModeCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkDisplayModeParametersKHR(handlemap, (VkDisplayModeParametersKHR*)(&toMap->parameters));
+}
+
+void handlemap_VkDisplayPlaneCapabilitiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPlaneCapabilitiesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->minSrcPosition));
+    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->maxSrcPosition));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minSrcExtent));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSrcExtent));
+    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->minDstPosition));
+    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->maxDstPosition));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minDstExtent));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxDstExtent));
+}
+
+void handlemap_VkDisplayPlanePropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPlanePropertiesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkDisplayKHR((VkDisplayKHR*)&toMap->currentDisplay);
+}
+
+void handlemap_VkDisplaySurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplaySurfaceCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->displayMode);
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->imageExtent));
+}
+
+#endif
+#ifdef VK_KHR_display_swapchain
+void handlemap_VkDisplayPresentInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPresentInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->srcRect));
+    handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->dstRect));
+}
+
+#endif
+#ifdef VK_KHR_xlib_surface
+void handlemap_VkXlibSurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkXlibSurfaceCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_xcb_surface
+void handlemap_VkXcbSurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkXcbSurfaceCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_wayland_surface
+void handlemap_VkWaylandSurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkWaylandSurfaceCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_mir_surface
+void handlemap_VkMirSurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkMirSurfaceCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_android_surface
+void handlemap_VkAndroidSurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkAndroidSurfaceCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_win32_surface
+void handlemap_VkWin32SurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkWin32SurfaceCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void handlemap_VkImportMemoryWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportMemoryWin32HandleInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportMemoryWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkExportMemoryWin32HandleInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMemoryWin32HandlePropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkMemoryWin32HandlePropertiesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMemoryGetWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkMemoryGetWin32HandleInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+void handlemap_VkImportMemoryFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportMemoryFdInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMemoryFdPropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkMemoryFdPropertiesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMemoryGetFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkMemoryGetFdInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pAcquireSyncs)
+    {
+        handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs, toMap->acquireCount);
+    }
+    if (toMap->pReleaseSyncs)
+    {
+        handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs, toMap->releaseCount);
+    }
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void handlemap_VkImportSemaphoreWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportSemaphoreWin32HandleInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+}
+
+void handlemap_VkExportSemaphoreWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkExportSemaphoreWin32HandleInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkD3D12FenceSubmitInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkD3D12FenceSubmitInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSemaphoreGetWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkSemaphoreGetWin32HandleInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void handlemap_VkImportSemaphoreFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportSemaphoreFdInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+}
+
+void handlemap_VkSemaphoreGetFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkSemaphoreGetFdInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+}
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDevicePushDescriptorPropertiesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void handlemap_VkRectLayerKHR(
+    VulkanHandleMapping* handlemap,
+    VkRectLayerKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->offset));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->extent));
+}
+
+void handlemap_VkPresentRegionKHR(
+    VulkanHandleMapping* handlemap,
+    VkPresentRegionKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pRectangles)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->rectangleCount; ++i)
+        {
+            handlemap_VkRectLayerKHR(handlemap, (VkRectLayerKHR*)(toMap->pRectangles + i));
+        }
+    }
+}
+
+void handlemap_VkPresentRegionsKHR(
+    VulkanHandleMapping* handlemap,
+    VkPresentRegionsKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pRegions)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->swapchainCount; ++i)
+        {
+            handlemap_VkPresentRegionKHR(handlemap, (VkPresentRegionKHR*)(toMap->pRegions + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+void handlemap_VkAttachmentDescription2KHR(
+    VulkanHandleMapping* handlemap,
+    VkAttachmentDescription2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkAttachmentReference2KHR(
+    VulkanHandleMapping* handlemap,
+    VkAttachmentReference2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSubpassDescription2KHR(
+    VulkanHandleMapping* handlemap,
+    VkSubpassDescription2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pInputAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i)
+        {
+            handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pInputAttachments + i));
+        }
+    }
+    if (toMap->pColorAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
+        {
+            handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pColorAttachments + i));
+        }
+    }
+    if (toMap->pResolveAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
+        {
+            handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pResolveAttachments + i));
+        }
+    }
+    if (toMap->pDepthStencilAttachment)
+    {
+        handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pDepthStencilAttachment));
+    }
+}
+
+void handlemap_VkSubpassDependency2KHR(
+    VulkanHandleMapping* handlemap,
+    VkSubpassDependency2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkRenderPassCreateInfo2KHR(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassCreateInfo2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
+        {
+            handlemap_VkAttachmentDescription2KHR(handlemap, (VkAttachmentDescription2KHR*)(toMap->pAttachments + i));
+        }
+    }
+    if (toMap->pSubpasses)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i)
+        {
+            handlemap_VkSubpassDescription2KHR(handlemap, (VkSubpassDescription2KHR*)(toMap->pSubpasses + i));
+        }
+    }
+    if (toMap->pDependencies)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i)
+        {
+            handlemap_VkSubpassDependency2KHR(handlemap, (VkSubpassDependency2KHR*)(toMap->pDependencies + i));
+        }
+    }
+}
+
+void handlemap_VkSubpassBeginInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkSubpassBeginInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSubpassEndInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkSubpassEndInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void handlemap_VkSharedPresentSurfaceCapabilitiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkSharedPresentSurfaceCapabilitiesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void handlemap_VkImportFenceWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportFenceWin32HandleInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
+}
+
+void handlemap_VkExportFenceWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkExportFenceWin32HandleInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkFenceGetWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkFenceGetWin32HandleInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
+}
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+void handlemap_VkImportFenceFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportFenceFdInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
+}
+
+void handlemap_VkFenceGetFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkFenceGetFdInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
+}
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void handlemap_VkPhysicalDeviceSurfaceInfo2KHR(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSurfaceInfo2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&toMap->surface);
+}
+
+void handlemap_VkSurfaceCapabilities2KHR(
+    VulkanHandleMapping* handlemap,
+    VkSurfaceCapabilities2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkSurfaceCapabilitiesKHR(handlemap, (VkSurfaceCapabilitiesKHR*)(&toMap->surfaceCapabilities));
+}
+
+void handlemap_VkSurfaceFormat2KHR(
+    VulkanHandleMapping* handlemap,
+    VkSurfaceFormat2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkSurfaceFormatKHR(handlemap, (VkSurfaceFormatKHR*)(&toMap->surfaceFormat));
+}
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void handlemap_VkDisplayProperties2KHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayProperties2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkDisplayPropertiesKHR(handlemap, (VkDisplayPropertiesKHR*)(&toMap->displayProperties));
+}
+
+void handlemap_VkDisplayPlaneProperties2KHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPlaneProperties2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkDisplayPlanePropertiesKHR(handlemap, (VkDisplayPlanePropertiesKHR*)(&toMap->displayPlaneProperties));
+}
+
+void handlemap_VkDisplayModeProperties2KHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayModeProperties2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkDisplayModePropertiesKHR(handlemap, (VkDisplayModePropertiesKHR*)(&toMap->displayModeProperties));
+}
+
+void handlemap_VkDisplayPlaneInfo2KHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPlaneInfo2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->mode);
+}
+
+void handlemap_VkDisplayPlaneCapabilities2KHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPlaneCapabilities2KHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkDisplayPlaneCapabilitiesKHR(handlemap, (VkDisplayPlaneCapabilitiesKHR*)(&toMap->capabilities));
+}
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+void handlemap_VkImageFormatListCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImageFormatListCreateInfoKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+void handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDevice8BitStorageFeaturesKHR* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void handlemap_VkNativeBufferANDROID(
+    VulkanHandleMapping* handlemap,
+    VkNativeBufferANDROID* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_debug_report
+void handlemap_VkDebugReportCallbackCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugReportCallbackCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(
+    VulkanHandleMapping* handlemap,
+    VkPipelineRasterizationStateRasterizationOrderAMD* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void handlemap_VkDebugMarkerObjectNameInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugMarkerObjectNameInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDebugMarkerObjectTagInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugMarkerObjectTagInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDebugMarkerMarkerInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugMarkerMarkerInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void handlemap_VkDedicatedAllocationImageCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkDedicatedAllocationImageCreateInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDedicatedAllocationBufferCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkDedicatedAllocationBufferCreateInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkDedicatedAllocationMemoryAllocateInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void handlemap_VkTextureLODGatherFormatPropertiesAMD(
+    VulkanHandleMapping* handlemap,
+    VkTextureLODGatherFormatPropertiesAMD* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_shader_info
+void handlemap_VkShaderResourceUsageAMD(
+    VulkanHandleMapping* handlemap,
+    VkShaderResourceUsageAMD* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkShaderStatisticsInfoAMD(
+    VulkanHandleMapping* handlemap,
+    VkShaderStatisticsInfoAMD* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkShaderResourceUsageAMD(handlemap, (VkShaderResourceUsageAMD*)(&toMap->resourceUsage));
+}
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void handlemap_VkExternalImageFormatPropertiesNV(
+    VulkanHandleMapping* handlemap,
+    VkExternalImageFormatPropertiesNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkImageFormatProperties(handlemap, (VkImageFormatProperties*)(&toMap->imageFormatProperties));
+}
+
+#endif
+#ifdef VK_NV_external_memory
+void handlemap_VkExternalMemoryImageCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkExternalMemoryImageCreateInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportMemoryAllocateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkExportMemoryAllocateInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void handlemap_VkImportMemoryWin32HandleInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkImportMemoryWin32HandleInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportMemoryWin32HandleInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkExportMemoryWin32HandleInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkWin32KeyedMutexAcquireReleaseInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pAcquireSyncs)
+    {
+        handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs, toMap->acquireCount);
+    }
+    if (toMap->pReleaseSyncs)
+    {
+        handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs, toMap->releaseCount);
+    }
+}
+
+#endif
+#ifdef VK_EXT_validation_flags
+void handlemap_VkValidationFlagsEXT(
+    VulkanHandleMapping* handlemap,
+    VkValidationFlagsEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NN_vi_surface
+void handlemap_VkViSurfaceCreateInfoNN(
+    VulkanHandleMapping* handlemap,
+    VkViSurfaceCreateInfoNN* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void handlemap_VkConditionalRenderingBeginInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkConditionalRenderingBeginInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkCommandBufferInheritanceConditionalRenderingInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void handlemap_VkDeviceGeneratedCommandsFeaturesNVX(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGeneratedCommandsFeaturesNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceGeneratedCommandsLimitsNVX(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGeneratedCommandsLimitsNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkIndirectCommandsTokenNVX(
+    VulkanHandleMapping* handlemap,
+    VkIndirectCommandsTokenNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkIndirectCommandsLayoutTokenNVX(
+    VulkanHandleMapping* handlemap,
+    VkIndirectCommandsLayoutTokenNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkIndirectCommandsLayoutCreateInfoNVX(
+    VulkanHandleMapping* handlemap,
+    VkIndirectCommandsLayoutCreateInfoNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pTokens)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->tokenCount; ++i)
+        {
+            handlemap_VkIndirectCommandsLayoutTokenNVX(handlemap, (VkIndirectCommandsLayoutTokenNVX*)(toMap->pTokens + i));
+        }
+    }
+}
+
+void handlemap_VkCmdProcessCommandsInfoNVX(
+    VulkanHandleMapping* handlemap,
+    VkCmdProcessCommandsInfoNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&toMap->objectTable);
+    handlemap->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&toMap->indirectCommandsLayout);
+    if (toMap->pIndirectCommandsTokens)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->indirectCommandsTokenCount; ++i)
+        {
+            handlemap_VkIndirectCommandsTokenNVX(handlemap, (VkIndirectCommandsTokenNVX*)(toMap->pIndirectCommandsTokens + i));
+        }
+    }
+    handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)&toMap->targetCommandBuffer);
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->sequencesCountBuffer);
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->sequencesIndexBuffer);
+}
+
+void handlemap_VkCmdReserveSpaceForCommandsInfoNVX(
+    VulkanHandleMapping* handlemap,
+    VkCmdReserveSpaceForCommandsInfoNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&toMap->objectTable);
+    handlemap->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&toMap->indirectCommandsLayout);
+}
+
+void handlemap_VkObjectTableCreateInfoNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTableCreateInfoNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkObjectTableEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTableEntryNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkObjectTablePipelineEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTablePipelineEntryNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->pipeline);
+}
+
+void handlemap_VkObjectTableDescriptorSetEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTableDescriptorSetEntryNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
+    handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->descriptorSet);
+}
+
+void handlemap_VkObjectTableVertexBufferEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTableVertexBufferEntryNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkObjectTableIndexBufferEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTableIndexBufferEntryNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkObjectTablePushConstantEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTablePushConstantEntryNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
+}
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void handlemap_VkViewportWScalingNV(
+    VulkanHandleMapping* handlemap,
+    VkViewportWScalingNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPipelineViewportWScalingStateCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkPipelineViewportWScalingStateCreateInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pViewportWScalings)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
+        {
+            handlemap_VkViewportWScalingNV(handlemap, (VkViewportWScalingNV*)(toMap->pViewportWScalings + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+void handlemap_VkSurfaceCapabilities2EXT(
+    VulkanHandleMapping* handlemap,
+    VkSurfaceCapabilities2EXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->currentExtent));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minImageExtent));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxImageExtent));
+}
+
+#endif
+#ifdef VK_EXT_display_control
+void handlemap_VkDisplayPowerInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPowerInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceEventInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDeviceEventInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDisplayEventInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDisplayEventInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSwapchainCounterCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkSwapchainCounterCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+void handlemap_VkRefreshCycleDurationGOOGLE(
+    VulkanHandleMapping* handlemap,
+    VkRefreshCycleDurationGOOGLE* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPastPresentationTimingGOOGLE(
+    VulkanHandleMapping* handlemap,
+    VkPastPresentationTimingGOOGLE* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPresentTimeGOOGLE(
+    VulkanHandleMapping* handlemap,
+    VkPresentTimeGOOGLE* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPresentTimesInfoGOOGLE(
+    VulkanHandleMapping* handlemap,
+    VkPresentTimesInfoGOOGLE* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pTimes)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->swapchainCount; ++i)
+        {
+            handlemap_VkPresentTimeGOOGLE(handlemap, (VkPresentTimeGOOGLE*)(toMap->pTimes + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void handlemap_VkViewportSwizzleNV(
+    VulkanHandleMapping* handlemap,
+    VkViewportSwizzleNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkPipelineViewportSwizzleStateCreateInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pViewportSwizzles)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
+        {
+            handlemap_VkViewportSwizzleNV(handlemap, (VkViewportSwizzleNV*)(toMap->pViewportSwizzles + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkPipelineDiscardRectangleStateCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pDiscardRectangles)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->discardRectangleCount; ++i)
+        {
+            handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pDiscardRectangles + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkPipelineRasterizationConservativeStateCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void handlemap_VkXYColorEXT(
+    VulkanHandleMapping* handlemap,
+    VkXYColorEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkHdrMetadataEXT(
+    VulkanHandleMapping* handlemap,
+    VkHdrMetadataEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->displayPrimaryRed));
+    handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->displayPrimaryGreen));
+    handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->displayPrimaryBlue));
+    handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->whitePoint));
+}
+
+#endif
+#ifdef VK_MVK_ios_surface
+void handlemap_VkIOSSurfaceCreateInfoMVK(
+    VulkanHandleMapping* handlemap,
+    VkIOSSurfaceCreateInfoMVK* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_MVK_macos_surface
+void handlemap_VkMacOSSurfaceCreateInfoMVK(
+    VulkanHandleMapping* handlemap,
+    VkMacOSSurfaceCreateInfoMVK* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void handlemap_VkDebugUtilsObjectNameInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugUtilsObjectNameInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDebugUtilsObjectTagInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugUtilsObjectTagInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDebugUtilsLabelEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugUtilsLabelEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDebugUtilsMessengerCallbackDataEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugUtilsMessengerCallbackDataEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pQueueLabels)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->queueLabelCount; ++i)
+        {
+            handlemap_VkDebugUtilsLabelEXT(handlemap, (VkDebugUtilsLabelEXT*)(toMap->pQueueLabels + i));
+        }
+    }
+    if (toMap->pCmdBufLabels)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->cmdBufLabelCount; ++i)
+        {
+            handlemap_VkDebugUtilsLabelEXT(handlemap, (VkDebugUtilsLabelEXT*)(toMap->pCmdBufLabels + i));
+        }
+    }
+    if (toMap->pObjects)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->objectCount; ++i)
+        {
+            handlemap_VkDebugUtilsObjectNameInfoEXT(handlemap, (VkDebugUtilsObjectNameInfoEXT*)(toMap->pObjects + i));
+        }
+    }
+}
+
+void handlemap_VkDebugUtilsMessengerCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugUtilsMessengerCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void handlemap_VkAndroidHardwareBufferUsageANDROID(
+    VulkanHandleMapping* handlemap,
+    VkAndroidHardwareBufferUsageANDROID* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkAndroidHardwareBufferPropertiesANDROID(
+    VulkanHandleMapping* handlemap,
+    VkAndroidHardwareBufferPropertiesANDROID* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(
+    VulkanHandleMapping* handlemap,
+    VkAndroidHardwareBufferFormatPropertiesANDROID* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->samplerYcbcrConversionComponents));
+}
+
+void handlemap_VkImportAndroidHardwareBufferInfoANDROID(
+    VulkanHandleMapping* handlemap,
+    VkImportAndroidHardwareBufferInfoANDROID* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+    VulkanHandleMapping* handlemap,
+    VkMemoryGetAndroidHardwareBufferInfoANDROID* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkExternalFormatANDROID(
+    VulkanHandleMapping* handlemap,
+    VkExternalFormatANDROID* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void handlemap_VkSamplerReductionModeCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkSamplerReductionModeCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void handlemap_VkSampleLocationEXT(
+    VulkanHandleMapping* handlemap,
+    VkSampleLocationEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkSampleLocationsInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkSampleLocationsInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->sampleLocationGridSize));
+    if (toMap->pSampleLocations)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->sampleLocationsCount; ++i)
+        {
+            handlemap_VkSampleLocationEXT(handlemap, (VkSampleLocationEXT*)(toMap->pSampleLocations + i));
+        }
+    }
+}
+
+void handlemap_VkAttachmentSampleLocationsEXT(
+    VulkanHandleMapping* handlemap,
+    VkAttachmentSampleLocationsEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
+}
+
+void handlemap_VkSubpassSampleLocationsEXT(
+    VulkanHandleMapping* handlemap,
+    VkSubpassSampleLocationsEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
+}
+
+void handlemap_VkRenderPassSampleLocationsBeginInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassSampleLocationsBeginInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pAttachmentInitialSampleLocations)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->attachmentInitialSampleLocationsCount; ++i)
+        {
+            handlemap_VkAttachmentSampleLocationsEXT(handlemap, (VkAttachmentSampleLocationsEXT*)(toMap->pAttachmentInitialSampleLocations + i));
+        }
+    }
+    if (toMap->pPostSubpassSampleLocations)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->postSubpassSampleLocationsCount; ++i)
+        {
+            handlemap_VkSubpassSampleLocationsEXT(handlemap, (VkSubpassSampleLocationsEXT*)(toMap->pPostSubpassSampleLocations + i));
+        }
+    }
+}
+
+void handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkPipelineSampleLocationsStateCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
+}
+
+void handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSampleLocationsPropertiesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSampleLocationGridSize));
+}
+
+void handlemap_VkMultisamplePropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkMultisamplePropertiesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSampleLocationGridSize));
+}
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkPipelineColorBlendAdvancedStateCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void handlemap_VkPipelineCoverageToColorStateCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkPipelineCoverageToColorStateCreateInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void handlemap_VkPipelineCoverageModulationStateCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkPipelineCoverageModulationStateCreateInfoNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void handlemap_VkValidationCacheCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkValidationCacheCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkShaderModuleValidationCacheCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkShaderModuleValidationCacheCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&toMap->validationCache);
+}
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceDescriptorIndexingFeaturesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceDescriptorIndexingPropertiesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void handlemap_VkImportMemoryHostPointerInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkImportMemoryHostPointerInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMemoryHostPointerPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkMemoryHostPointerPropertiesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+void handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceShaderCorePropertiesAMD* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkVertexInputBindingDivisorDescriptionEXT(
+    VulkanHandleMapping* handlemap,
+    VkVertexInputBindingDivisorDescriptionEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkPipelineVertexInputDivisorStateCreateInfoEXT* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pVertexBindingDivisors)
+    {
+        for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDivisorCount; ++i)
+        {
+            handlemap_VkVertexInputBindingDivisorDescriptionEXT(handlemap, (VkVertexInputBindingDivisorDescriptionEXT*)(toMap->pVertexBindingDivisors + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void handlemap_VkQueueFamilyCheckpointPropertiesNV(
+    VulkanHandleMapping* handlemap,
+    VkQueueFamilyCheckpointPropertiesNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkCheckpointDataNV(
+    VulkanHandleMapping* handlemap,
+    VkCheckpointDataNV* toMap)
+{
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext)
+    {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+void handlemap_extension_struct(
+    VulkanHandleMapping* handlemap,
+    void* structExtension_out)
+{
+    if (!structExtension_out)
+    {
+        return;
+    }
+    uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
+    switch(structType)
+    {
+#ifdef VK_VERSION_1_1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+        {
+            handlemap_VkPhysicalDeviceSubgroupProperties(handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+        {
+            handlemap_VkPhysicalDevice16BitStorageFeatures(handlemap, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+        {
+            handlemap_VkMemoryDedicatedRequirements(handlemap, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+        {
+            handlemap_VkMemoryDedicatedAllocateInfo(handlemap, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+        {
+            handlemap_VkMemoryAllocateFlagsInfo(handlemap, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+        {
+            handlemap_VkDeviceGroupRenderPassBeginInfo(handlemap, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+        {
+            handlemap_VkDeviceGroupCommandBufferBeginInfo(handlemap, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+        {
+            handlemap_VkDeviceGroupSubmitInfo(handlemap, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+        {
+            handlemap_VkDeviceGroupBindSparseInfo(handlemap, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+        {
+            handlemap_VkBindBufferMemoryDeviceGroupInfo(handlemap, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+        {
+            handlemap_VkBindImageMemoryDeviceGroupInfo(handlemap, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+        {
+            handlemap_VkDeviceGroupDeviceCreateInfo(handlemap, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+        {
+            handlemap_VkPhysicalDeviceFeatures2(handlemap, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+        {
+            handlemap_VkPhysicalDevicePointClippingProperties(handlemap, reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+        {
+            handlemap_VkRenderPassInputAttachmentAspectCreateInfo(handlemap, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+        {
+            handlemap_VkImageViewUsageCreateInfo(handlemap, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+        {
+            handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(handlemap, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+        {
+            handlemap_VkRenderPassMultiviewCreateInfo(handlemap, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+        {
+            handlemap_VkPhysicalDeviceMultiviewFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+        {
+            handlemap_VkPhysicalDeviceMultiviewProperties(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
+        {
+            handlemap_VkPhysicalDeviceVariablePointerFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+        {
+            handlemap_VkPhysicalDeviceProtectedMemoryFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+        {
+            handlemap_VkPhysicalDeviceProtectedMemoryProperties(handlemap, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+        {
+            handlemap_VkProtectedSubmitInfo(handlemap, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+        {
+            handlemap_VkSamplerYcbcrConversionInfo(handlemap, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+        {
+            handlemap_VkBindImagePlaneMemoryInfo(handlemap, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+        {
+            handlemap_VkImagePlaneMemoryRequirementsInfo(handlemap, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+        {
+            handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+        {
+            handlemap_VkSamplerYcbcrConversionImageFormatProperties(handlemap, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+        {
+            handlemap_VkPhysicalDeviceExternalImageFormatInfo(handlemap, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+        {
+            handlemap_VkExternalImageFormatProperties(handlemap, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+        {
+            handlemap_VkPhysicalDeviceIDProperties(handlemap, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+        {
+            handlemap_VkExternalMemoryImageCreateInfo(handlemap, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+        {
+            handlemap_VkExternalMemoryBufferCreateInfo(handlemap, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+        {
+            handlemap_VkExportMemoryAllocateInfo(handlemap, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+        {
+            handlemap_VkExportFenceCreateInfo(handlemap, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+        {
+            handlemap_VkExportSemaphoreCreateInfo(handlemap, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+        {
+            handlemap_VkPhysicalDeviceMaintenance3Properties(handlemap, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
+        {
+            handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_swapchain
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+        {
+            handlemap_VkImageSwapchainCreateInfoKHR(handlemap, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+        {
+            handlemap_VkBindImageMemorySwapchainInfoKHR(handlemap, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+        {
+            handlemap_VkDeviceGroupPresentInfoKHR(handlemap, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+        {
+            handlemap_VkDeviceGroupSwapchainCreateInfoKHR(handlemap, reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_display_swapchain
+        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+        {
+            handlemap_VkDisplayPresentInfoKHR(handlemap, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_memory_win32
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            handlemap_VkImportMemoryWin32HandleInfoKHR(handlemap, reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            handlemap_VkExportMemoryWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_memory_fd
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+        {
+            handlemap_VkImportMemoryFdInfoKHR(handlemap, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+        {
+            handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(handlemap, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+        {
+            handlemap_VkExportSemaphoreWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+        {
+            handlemap_VkD3D12FenceSubmitInfoKHR(handlemap, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_push_descriptor
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+        {
+            handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_incremental_present
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+        {
+            handlemap_VkPresentRegionsKHR(handlemap, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+        {
+            handlemap_VkSharedPresentSurfaceCapabilitiesKHR(handlemap, reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_fence_win32
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+        {
+            handlemap_VkExportFenceWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_image_format_list
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+        {
+            handlemap_VkImageFormatListCreateInfoKHR(handlemap, reinterpret_cast<VkImageFormatListCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_8bit_storage
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+        {
+            handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ANDROID_native_buffer
+        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
+        {
+            handlemap_VkNativeBufferANDROID(handlemap, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_debug_report
+        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+        {
+            handlemap_VkDebugReportCallbackCreateInfoEXT(handlemap, reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_rasterization_order
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+        {
+            handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(handlemap, reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_dedicated_allocation
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+        {
+            handlemap_VkDedicatedAllocationImageCreateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+        {
+            handlemap_VkDedicatedAllocationBufferCreateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+        {
+            handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+        {
+            handlemap_VkTextureLODGatherFormatPropertiesAMD(handlemap, reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_external_memory
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+        {
+            handlemap_VkExternalMemoryImageCreateInfoNV(handlemap, reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+        {
+            handlemap_VkExportMemoryAllocateInfoNV(handlemap, reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_external_memory_win32
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+        {
+            handlemap_VkImportMemoryWin32HandleInfoNV(handlemap, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+        {
+            handlemap_VkExportMemoryWin32HandleInfoNV(handlemap, reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+        {
+            handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(handlemap, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_validation_flags
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+        {
+            handlemap_VkValidationFlagsEXT(handlemap, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_conditional_rendering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+        {
+            handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+        {
+            handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(handlemap, reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+        {
+            handlemap_VkPipelineViewportWScalingStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_display_control
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+        {
+            handlemap_VkSwapchainCounterCreateInfoEXT(handlemap, reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_GOOGLE_display_timing
+        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+        {
+            handlemap_VkPresentTimesInfoGOOGLE(handlemap, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+        {
+            handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_viewport_swizzle
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+        {
+            handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_discard_rectangles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+        {
+            handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+        {
+            handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_conservative_rasterization
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+        {
+            handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+        {
+            handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+        {
+            handlemap_VkDebugUtilsMessengerCreateInfoEXT(handlemap, reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+        {
+            handlemap_VkAndroidHardwareBufferUsageANDROID(handlemap, reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+        {
+            handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(handlemap, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+        {
+            handlemap_VkImportAndroidHardwareBufferInfoANDROID(handlemap, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+        {
+            handlemap_VkExternalFormatANDROID(handlemap, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+        {
+            handlemap_VkSamplerReductionModeCreateInfoEXT(handlemap, reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+        {
+            handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_sample_locations
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+        {
+            handlemap_VkSampleLocationsInfoEXT(handlemap, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+        {
+            handlemap_VkRenderPassSampleLocationsBeginInfoEXT(handlemap, reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+        {
+            handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+        {
+            handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+        {
+            handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+        {
+            handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+        {
+            handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+        {
+            handlemap_VkPipelineCoverageToColorStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+        {
+            handlemap_VkPipelineCoverageModulationStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_validation_cache
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+        {
+            handlemap_VkShaderModuleValidationCacheCreateInfoEXT(handlemap, reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_indexing
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+        {
+            handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(handlemap, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+        {
+            handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+        {
+            handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+        {
+            handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(handlemap, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+        {
+            handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(handlemap, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
+        {
+            handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(handlemap, reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_external_memory_host
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+        {
+            handlemap_VkImportMemoryHostPointerInfoEXT(handlemap, reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+        {
+            handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+        {
+            handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(handlemap, reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+        {
+            handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+        {
+            handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+        {
+            handlemap_VkQueueFamilyCheckpointPropertiesNV(handlemap, reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+            break;
+        }
+#endif
+        default:
+        {
+            return;
+        }
+    }
+}
+
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.h b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
new file mode 100644
index 0000000..d961965
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
@@ -0,0 +1,1667 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_handlemap_guest
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "vk_platform_compat.h"
+
+#include "goldfish_vk_private_defs.h"
+#include "VulkanHandleMapping.h"
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+void handlemap_VkApplicationInfo(
+    VulkanHandleMapping* handlemap,
+    VkApplicationInfo* toMap);
+
+void handlemap_VkInstanceCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkInstanceCreateInfo* toMap);
+
+void handlemap_VkAllocationCallbacks(
+    VulkanHandleMapping* handlemap,
+    VkAllocationCallbacks* toMap);
+
+void handlemap_VkPhysicalDeviceFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceFeatures* toMap);
+
+void handlemap_VkFormatProperties(
+    VulkanHandleMapping* handlemap,
+    VkFormatProperties* toMap);
+
+void handlemap_VkExtent3D(
+    VulkanHandleMapping* handlemap,
+    VkExtent3D* toMap);
+
+void handlemap_VkImageFormatProperties(
+    VulkanHandleMapping* handlemap,
+    VkImageFormatProperties* toMap);
+
+void handlemap_VkPhysicalDeviceLimits(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceLimits* toMap);
+
+void handlemap_VkPhysicalDeviceSparseProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSparseProperties* toMap);
+
+void handlemap_VkPhysicalDeviceProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceProperties* toMap);
+
+void handlemap_VkQueueFamilyProperties(
+    VulkanHandleMapping* handlemap,
+    VkQueueFamilyProperties* toMap);
+
+void handlemap_VkMemoryType(
+    VulkanHandleMapping* handlemap,
+    VkMemoryType* toMap);
+
+void handlemap_VkMemoryHeap(
+    VulkanHandleMapping* handlemap,
+    VkMemoryHeap* toMap);
+
+void handlemap_VkPhysicalDeviceMemoryProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMemoryProperties* toMap);
+
+void handlemap_VkDeviceQueueCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceQueueCreateInfo* toMap);
+
+void handlemap_VkDeviceCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceCreateInfo* toMap);
+
+void handlemap_VkExtensionProperties(
+    VulkanHandleMapping* handlemap,
+    VkExtensionProperties* toMap);
+
+void handlemap_VkLayerProperties(
+    VulkanHandleMapping* handlemap,
+    VkLayerProperties* toMap);
+
+void handlemap_VkSubmitInfo(
+    VulkanHandleMapping* handlemap,
+    VkSubmitInfo* toMap);
+
+void handlemap_VkMemoryAllocateInfo(
+    VulkanHandleMapping* handlemap,
+    VkMemoryAllocateInfo* toMap);
+
+void handlemap_VkMappedMemoryRange(
+    VulkanHandleMapping* handlemap,
+    VkMappedMemoryRange* toMap);
+
+void handlemap_VkMemoryRequirements(
+    VulkanHandleMapping* handlemap,
+    VkMemoryRequirements* toMap);
+
+void handlemap_VkSparseImageFormatProperties(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageFormatProperties* toMap);
+
+void handlemap_VkSparseImageMemoryRequirements(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageMemoryRequirements* toMap);
+
+void handlemap_VkSparseMemoryBind(
+    VulkanHandleMapping* handlemap,
+    VkSparseMemoryBind* toMap);
+
+void handlemap_VkSparseBufferMemoryBindInfo(
+    VulkanHandleMapping* handlemap,
+    VkSparseBufferMemoryBindInfo* toMap);
+
+void handlemap_VkSparseImageOpaqueMemoryBindInfo(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageOpaqueMemoryBindInfo* toMap);
+
+void handlemap_VkImageSubresource(
+    VulkanHandleMapping* handlemap,
+    VkImageSubresource* toMap);
+
+void handlemap_VkOffset3D(
+    VulkanHandleMapping* handlemap,
+    VkOffset3D* toMap);
+
+void handlemap_VkSparseImageMemoryBind(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageMemoryBind* toMap);
+
+void handlemap_VkSparseImageMemoryBindInfo(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageMemoryBindInfo* toMap);
+
+void handlemap_VkBindSparseInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindSparseInfo* toMap);
+
+void handlemap_VkFenceCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkFenceCreateInfo* toMap);
+
+void handlemap_VkSemaphoreCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkSemaphoreCreateInfo* toMap);
+
+void handlemap_VkEventCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkEventCreateInfo* toMap);
+
+void handlemap_VkQueryPoolCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkQueryPoolCreateInfo* toMap);
+
+void handlemap_VkBufferCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkBufferCreateInfo* toMap);
+
+void handlemap_VkBufferViewCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkBufferViewCreateInfo* toMap);
+
+void handlemap_VkImageCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkImageCreateInfo* toMap);
+
+void handlemap_VkSubresourceLayout(
+    VulkanHandleMapping* handlemap,
+    VkSubresourceLayout* toMap);
+
+void handlemap_VkComponentMapping(
+    VulkanHandleMapping* handlemap,
+    VkComponentMapping* toMap);
+
+void handlemap_VkImageSubresourceRange(
+    VulkanHandleMapping* handlemap,
+    VkImageSubresourceRange* toMap);
+
+void handlemap_VkImageViewCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkImageViewCreateInfo* toMap);
+
+void handlemap_VkShaderModuleCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkShaderModuleCreateInfo* toMap);
+
+void handlemap_VkPipelineCacheCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineCacheCreateInfo* toMap);
+
+void handlemap_VkSpecializationMapEntry(
+    VulkanHandleMapping* handlemap,
+    VkSpecializationMapEntry* toMap);
+
+void handlemap_VkSpecializationInfo(
+    VulkanHandleMapping* handlemap,
+    VkSpecializationInfo* toMap);
+
+void handlemap_VkPipelineShaderStageCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineShaderStageCreateInfo* toMap);
+
+void handlemap_VkVertexInputBindingDescription(
+    VulkanHandleMapping* handlemap,
+    VkVertexInputBindingDescription* toMap);
+
+void handlemap_VkVertexInputAttributeDescription(
+    VulkanHandleMapping* handlemap,
+    VkVertexInputAttributeDescription* toMap);
+
+void handlemap_VkPipelineVertexInputStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineVertexInputStateCreateInfo* toMap);
+
+void handlemap_VkPipelineInputAssemblyStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineInputAssemblyStateCreateInfo* toMap);
+
+void handlemap_VkPipelineTessellationStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineTessellationStateCreateInfo* toMap);
+
+void handlemap_VkViewport(
+    VulkanHandleMapping* handlemap,
+    VkViewport* toMap);
+
+void handlemap_VkOffset2D(
+    VulkanHandleMapping* handlemap,
+    VkOffset2D* toMap);
+
+void handlemap_VkExtent2D(
+    VulkanHandleMapping* handlemap,
+    VkExtent2D* toMap);
+
+void handlemap_VkRect2D(
+    VulkanHandleMapping* handlemap,
+    VkRect2D* toMap);
+
+void handlemap_VkPipelineViewportStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineViewportStateCreateInfo* toMap);
+
+void handlemap_VkPipelineRasterizationStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineRasterizationStateCreateInfo* toMap);
+
+void handlemap_VkPipelineMultisampleStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineMultisampleStateCreateInfo* toMap);
+
+void handlemap_VkStencilOpState(
+    VulkanHandleMapping* handlemap,
+    VkStencilOpState* toMap);
+
+void handlemap_VkPipelineDepthStencilStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineDepthStencilStateCreateInfo* toMap);
+
+void handlemap_VkPipelineColorBlendAttachmentState(
+    VulkanHandleMapping* handlemap,
+    VkPipelineColorBlendAttachmentState* toMap);
+
+void handlemap_VkPipelineColorBlendStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineColorBlendStateCreateInfo* toMap);
+
+void handlemap_VkPipelineDynamicStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineDynamicStateCreateInfo* toMap);
+
+void handlemap_VkGraphicsPipelineCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkGraphicsPipelineCreateInfo* toMap);
+
+void handlemap_VkComputePipelineCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkComputePipelineCreateInfo* toMap);
+
+void handlemap_VkPushConstantRange(
+    VulkanHandleMapping* handlemap,
+    VkPushConstantRange* toMap);
+
+void handlemap_VkPipelineLayoutCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineLayoutCreateInfo* toMap);
+
+void handlemap_VkSamplerCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkSamplerCreateInfo* toMap);
+
+void handlemap_VkDescriptorSetLayoutBinding(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetLayoutBinding* toMap);
+
+void handlemap_VkDescriptorSetLayoutCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetLayoutCreateInfo* toMap);
+
+void handlemap_VkDescriptorPoolSize(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorPoolSize* toMap);
+
+void handlemap_VkDescriptorPoolCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorPoolCreateInfo* toMap);
+
+void handlemap_VkDescriptorSetAllocateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetAllocateInfo* toMap);
+
+void handlemap_VkDescriptorImageInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorImageInfo* toMap);
+
+void handlemap_VkDescriptorBufferInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorBufferInfo* toMap);
+
+void handlemap_VkWriteDescriptorSet(
+    VulkanHandleMapping* handlemap,
+    VkWriteDescriptorSet* toMap);
+
+void handlemap_VkCopyDescriptorSet(
+    VulkanHandleMapping* handlemap,
+    VkCopyDescriptorSet* toMap);
+
+void handlemap_VkFramebufferCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkFramebufferCreateInfo* toMap);
+
+void handlemap_VkAttachmentDescription(
+    VulkanHandleMapping* handlemap,
+    VkAttachmentDescription* toMap);
+
+void handlemap_VkAttachmentReference(
+    VulkanHandleMapping* handlemap,
+    VkAttachmentReference* toMap);
+
+void handlemap_VkSubpassDescription(
+    VulkanHandleMapping* handlemap,
+    VkSubpassDescription* toMap);
+
+void handlemap_VkSubpassDependency(
+    VulkanHandleMapping* handlemap,
+    VkSubpassDependency* toMap);
+
+void handlemap_VkRenderPassCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassCreateInfo* toMap);
+
+void handlemap_VkCommandPoolCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkCommandPoolCreateInfo* toMap);
+
+void handlemap_VkCommandBufferAllocateInfo(
+    VulkanHandleMapping* handlemap,
+    VkCommandBufferAllocateInfo* toMap);
+
+void handlemap_VkCommandBufferInheritanceInfo(
+    VulkanHandleMapping* handlemap,
+    VkCommandBufferInheritanceInfo* toMap);
+
+void handlemap_VkCommandBufferBeginInfo(
+    VulkanHandleMapping* handlemap,
+    VkCommandBufferBeginInfo* toMap);
+
+void handlemap_VkBufferCopy(
+    VulkanHandleMapping* handlemap,
+    VkBufferCopy* toMap);
+
+void handlemap_VkImageSubresourceLayers(
+    VulkanHandleMapping* handlemap,
+    VkImageSubresourceLayers* toMap);
+
+void handlemap_VkImageCopy(
+    VulkanHandleMapping* handlemap,
+    VkImageCopy* toMap);
+
+void handlemap_VkImageBlit(
+    VulkanHandleMapping* handlemap,
+    VkImageBlit* toMap);
+
+void handlemap_VkBufferImageCopy(
+    VulkanHandleMapping* handlemap,
+    VkBufferImageCopy* toMap);
+
+void handlemap_VkClearColorValue(
+    VulkanHandleMapping* handlemap,
+    VkClearColorValue* toMap);
+
+void handlemap_VkClearDepthStencilValue(
+    VulkanHandleMapping* handlemap,
+    VkClearDepthStencilValue* toMap);
+
+void handlemap_VkClearValue(
+    VulkanHandleMapping* handlemap,
+    VkClearValue* toMap);
+
+void handlemap_VkClearAttachment(
+    VulkanHandleMapping* handlemap,
+    VkClearAttachment* toMap);
+
+void handlemap_VkClearRect(
+    VulkanHandleMapping* handlemap,
+    VkClearRect* toMap);
+
+void handlemap_VkImageResolve(
+    VulkanHandleMapping* handlemap,
+    VkImageResolve* toMap);
+
+void handlemap_VkMemoryBarrier(
+    VulkanHandleMapping* handlemap,
+    VkMemoryBarrier* toMap);
+
+void handlemap_VkBufferMemoryBarrier(
+    VulkanHandleMapping* handlemap,
+    VkBufferMemoryBarrier* toMap);
+
+void handlemap_VkImageMemoryBarrier(
+    VulkanHandleMapping* handlemap,
+    VkImageMemoryBarrier* toMap);
+
+void handlemap_VkRenderPassBeginInfo(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassBeginInfo* toMap);
+
+void handlemap_VkDispatchIndirectCommand(
+    VulkanHandleMapping* handlemap,
+    VkDispatchIndirectCommand* toMap);
+
+void handlemap_VkDrawIndexedIndirectCommand(
+    VulkanHandleMapping* handlemap,
+    VkDrawIndexedIndirectCommand* toMap);
+
+void handlemap_VkDrawIndirectCommand(
+    VulkanHandleMapping* handlemap,
+    VkDrawIndirectCommand* toMap);
+
+void handlemap_VkBaseOutStructure(
+    VulkanHandleMapping* handlemap,
+    VkBaseOutStructure* toMap);
+
+void handlemap_VkBaseInStructure(
+    VulkanHandleMapping* handlemap,
+    VkBaseInStructure* toMap);
+
+#endif
+#ifdef VK_VERSION_1_1
+void handlemap_VkPhysicalDeviceSubgroupProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSubgroupProperties* toMap);
+
+void handlemap_VkBindBufferMemoryInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindBufferMemoryInfo* toMap);
+
+void handlemap_VkBindImageMemoryInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindImageMemoryInfo* toMap);
+
+void handlemap_VkPhysicalDevice16BitStorageFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDevice16BitStorageFeatures* toMap);
+
+void handlemap_VkMemoryDedicatedRequirements(
+    VulkanHandleMapping* handlemap,
+    VkMemoryDedicatedRequirements* toMap);
+
+void handlemap_VkMemoryDedicatedAllocateInfo(
+    VulkanHandleMapping* handlemap,
+    VkMemoryDedicatedAllocateInfo* toMap);
+
+void handlemap_VkMemoryAllocateFlagsInfo(
+    VulkanHandleMapping* handlemap,
+    VkMemoryAllocateFlagsInfo* toMap);
+
+void handlemap_VkDeviceGroupRenderPassBeginInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupRenderPassBeginInfo* toMap);
+
+void handlemap_VkDeviceGroupCommandBufferBeginInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupCommandBufferBeginInfo* toMap);
+
+void handlemap_VkDeviceGroupSubmitInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupSubmitInfo* toMap);
+
+void handlemap_VkDeviceGroupBindSparseInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupBindSparseInfo* toMap);
+
+void handlemap_VkBindBufferMemoryDeviceGroupInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindBufferMemoryDeviceGroupInfo* toMap);
+
+void handlemap_VkBindImageMemoryDeviceGroupInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindImageMemoryDeviceGroupInfo* toMap);
+
+void handlemap_VkPhysicalDeviceGroupProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceGroupProperties* toMap);
+
+void handlemap_VkDeviceGroupDeviceCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupDeviceCreateInfo* toMap);
+
+void handlemap_VkBufferMemoryRequirementsInfo2(
+    VulkanHandleMapping* handlemap,
+    VkBufferMemoryRequirementsInfo2* toMap);
+
+void handlemap_VkImageMemoryRequirementsInfo2(
+    VulkanHandleMapping* handlemap,
+    VkImageMemoryRequirementsInfo2* toMap);
+
+void handlemap_VkImageSparseMemoryRequirementsInfo2(
+    VulkanHandleMapping* handlemap,
+    VkImageSparseMemoryRequirementsInfo2* toMap);
+
+void handlemap_VkMemoryRequirements2(
+    VulkanHandleMapping* handlemap,
+    VkMemoryRequirements2* toMap);
+
+void handlemap_VkSparseImageMemoryRequirements2(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageMemoryRequirements2* toMap);
+
+void handlemap_VkPhysicalDeviceFeatures2(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceFeatures2* toMap);
+
+void handlemap_VkPhysicalDeviceProperties2(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceProperties2* toMap);
+
+void handlemap_VkFormatProperties2(
+    VulkanHandleMapping* handlemap,
+    VkFormatProperties2* toMap);
+
+void handlemap_VkImageFormatProperties2(
+    VulkanHandleMapping* handlemap,
+    VkImageFormatProperties2* toMap);
+
+void handlemap_VkPhysicalDeviceImageFormatInfo2(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceImageFormatInfo2* toMap);
+
+void handlemap_VkQueueFamilyProperties2(
+    VulkanHandleMapping* handlemap,
+    VkQueueFamilyProperties2* toMap);
+
+void handlemap_VkPhysicalDeviceMemoryProperties2(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMemoryProperties2* toMap);
+
+void handlemap_VkSparseImageFormatProperties2(
+    VulkanHandleMapping* handlemap,
+    VkSparseImageFormatProperties2* toMap);
+
+void handlemap_VkPhysicalDeviceSparseImageFormatInfo2(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSparseImageFormatInfo2* toMap);
+
+void handlemap_VkPhysicalDevicePointClippingProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDevicePointClippingProperties* toMap);
+
+void handlemap_VkInputAttachmentAspectReference(
+    VulkanHandleMapping* handlemap,
+    VkInputAttachmentAspectReference* toMap);
+
+void handlemap_VkRenderPassInputAttachmentAspectCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassInputAttachmentAspectCreateInfo* toMap);
+
+void handlemap_VkImageViewUsageCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkImageViewUsageCreateInfo* toMap);
+
+void handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkPipelineTessellationDomainOriginStateCreateInfo* toMap);
+
+void handlemap_VkRenderPassMultiviewCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassMultiviewCreateInfo* toMap);
+
+void handlemap_VkPhysicalDeviceMultiviewFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMultiviewFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceMultiviewProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMultiviewProperties* toMap);
+
+void handlemap_VkPhysicalDeviceVariablePointerFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceVariablePointerFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceProtectedMemoryFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceProtectedMemoryFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceProtectedMemoryProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceProtectedMemoryProperties* toMap);
+
+void handlemap_VkDeviceQueueInfo2(
+    VulkanHandleMapping* handlemap,
+    VkDeviceQueueInfo2* toMap);
+
+void handlemap_VkProtectedSubmitInfo(
+    VulkanHandleMapping* handlemap,
+    VkProtectedSubmitInfo* toMap);
+
+void handlemap_VkSamplerYcbcrConversionCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkSamplerYcbcrConversionCreateInfo* toMap);
+
+void handlemap_VkSamplerYcbcrConversionInfo(
+    VulkanHandleMapping* handlemap,
+    VkSamplerYcbcrConversionInfo* toMap);
+
+void handlemap_VkBindImagePlaneMemoryInfo(
+    VulkanHandleMapping* handlemap,
+    VkBindImagePlaneMemoryInfo* toMap);
+
+void handlemap_VkImagePlaneMemoryRequirementsInfo(
+    VulkanHandleMapping* handlemap,
+    VkImagePlaneMemoryRequirementsInfo* toMap);
+
+void handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap);
+
+void handlemap_VkSamplerYcbcrConversionImageFormatProperties(
+    VulkanHandleMapping* handlemap,
+    VkSamplerYcbcrConversionImageFormatProperties* toMap);
+
+void handlemap_VkDescriptorUpdateTemplateEntry(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorUpdateTemplateEntry* toMap);
+
+void handlemap_VkDescriptorUpdateTemplateCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorUpdateTemplateCreateInfo* toMap);
+
+void handlemap_VkExternalMemoryProperties(
+    VulkanHandleMapping* handlemap,
+    VkExternalMemoryProperties* toMap);
+
+void handlemap_VkPhysicalDeviceExternalImageFormatInfo(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceExternalImageFormatInfo* toMap);
+
+void handlemap_VkExternalImageFormatProperties(
+    VulkanHandleMapping* handlemap,
+    VkExternalImageFormatProperties* toMap);
+
+void handlemap_VkPhysicalDeviceExternalBufferInfo(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceExternalBufferInfo* toMap);
+
+void handlemap_VkExternalBufferProperties(
+    VulkanHandleMapping* handlemap,
+    VkExternalBufferProperties* toMap);
+
+void handlemap_VkPhysicalDeviceIDProperties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceIDProperties* toMap);
+
+void handlemap_VkExternalMemoryImageCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkExternalMemoryImageCreateInfo* toMap);
+
+void handlemap_VkExternalMemoryBufferCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkExternalMemoryBufferCreateInfo* toMap);
+
+void handlemap_VkExportMemoryAllocateInfo(
+    VulkanHandleMapping* handlemap,
+    VkExportMemoryAllocateInfo* toMap);
+
+void handlemap_VkPhysicalDeviceExternalFenceInfo(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceExternalFenceInfo* toMap);
+
+void handlemap_VkExternalFenceProperties(
+    VulkanHandleMapping* handlemap,
+    VkExternalFenceProperties* toMap);
+
+void handlemap_VkExportFenceCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkExportFenceCreateInfo* toMap);
+
+void handlemap_VkExportSemaphoreCreateInfo(
+    VulkanHandleMapping* handlemap,
+    VkExportSemaphoreCreateInfo* toMap);
+
+void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceExternalSemaphoreInfo* toMap);
+
+void handlemap_VkExternalSemaphoreProperties(
+    VulkanHandleMapping* handlemap,
+    VkExternalSemaphoreProperties* toMap);
+
+void handlemap_VkPhysicalDeviceMaintenance3Properties(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMaintenance3Properties* toMap);
+
+void handlemap_VkDescriptorSetLayoutSupport(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetLayoutSupport* toMap);
+
+void handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceShaderDrawParameterFeatures* toMap);
+
+#endif
+#ifdef VK_KHR_surface
+void handlemap_VkSurfaceCapabilitiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkSurfaceCapabilitiesKHR* toMap);
+
+void handlemap_VkSurfaceFormatKHR(
+    VulkanHandleMapping* handlemap,
+    VkSurfaceFormatKHR* toMap);
+
+#endif
+#ifdef VK_KHR_swapchain
+void handlemap_VkSwapchainCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkSwapchainCreateInfoKHR* toMap);
+
+void handlemap_VkPresentInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkPresentInfoKHR* toMap);
+
+void handlemap_VkImageSwapchainCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImageSwapchainCreateInfoKHR* toMap);
+
+void handlemap_VkBindImageMemorySwapchainInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkBindImageMemorySwapchainInfoKHR* toMap);
+
+void handlemap_VkAcquireNextImageInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkAcquireNextImageInfoKHR* toMap);
+
+void handlemap_VkDeviceGroupPresentCapabilitiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupPresentCapabilitiesKHR* toMap);
+
+void handlemap_VkDeviceGroupPresentInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupPresentInfoKHR* toMap);
+
+void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGroupSwapchainCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_display
+void handlemap_VkDisplayPropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPropertiesKHR* toMap);
+
+void handlemap_VkDisplayModeParametersKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayModeParametersKHR* toMap);
+
+void handlemap_VkDisplayModePropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayModePropertiesKHR* toMap);
+
+void handlemap_VkDisplayModeCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayModeCreateInfoKHR* toMap);
+
+void handlemap_VkDisplayPlaneCapabilitiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPlaneCapabilitiesKHR* toMap);
+
+void handlemap_VkDisplayPlanePropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPlanePropertiesKHR* toMap);
+
+void handlemap_VkDisplaySurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplaySurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_display_swapchain
+void handlemap_VkDisplayPresentInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPresentInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_xlib_surface
+void handlemap_VkXlibSurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkXlibSurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_xcb_surface
+void handlemap_VkXcbSurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkXcbSurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_wayland_surface
+void handlemap_VkWaylandSurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkWaylandSurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_mir_surface
+void handlemap_VkMirSurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkMirSurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_android_surface
+void handlemap_VkAndroidSurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkAndroidSurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_win32_surface
+void handlemap_VkWin32SurfaceCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkWin32SurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void handlemap_VkImportMemoryWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportMemoryWin32HandleInfoKHR* toMap);
+
+void handlemap_VkExportMemoryWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkExportMemoryWin32HandleInfoKHR* toMap);
+
+void handlemap_VkMemoryWin32HandlePropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkMemoryWin32HandlePropertiesKHR* toMap);
+
+void handlemap_VkMemoryGetWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkMemoryGetWin32HandleInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+void handlemap_VkImportMemoryFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportMemoryFdInfoKHR* toMap);
+
+void handlemap_VkMemoryFdPropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkMemoryFdPropertiesKHR* toMap);
+
+void handlemap_VkMemoryGetFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkMemoryGetFdInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void handlemap_VkImportSemaphoreWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportSemaphoreWin32HandleInfoKHR* toMap);
+
+void handlemap_VkExportSemaphoreWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkExportSemaphoreWin32HandleInfoKHR* toMap);
+
+void handlemap_VkD3D12FenceSubmitInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkD3D12FenceSubmitInfoKHR* toMap);
+
+void handlemap_VkSemaphoreGetWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkSemaphoreGetWin32HandleInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void handlemap_VkImportSemaphoreFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportSemaphoreFdInfoKHR* toMap);
+
+void handlemap_VkSemaphoreGetFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkSemaphoreGetFdInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDevicePushDescriptorPropertiesKHR* toMap);
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void handlemap_VkRectLayerKHR(
+    VulkanHandleMapping* handlemap,
+    VkRectLayerKHR* toMap);
+
+void handlemap_VkPresentRegionKHR(
+    VulkanHandleMapping* handlemap,
+    VkPresentRegionKHR* toMap);
+
+void handlemap_VkPresentRegionsKHR(
+    VulkanHandleMapping* handlemap,
+    VkPresentRegionsKHR* toMap);
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+void handlemap_VkAttachmentDescription2KHR(
+    VulkanHandleMapping* handlemap,
+    VkAttachmentDescription2KHR* toMap);
+
+void handlemap_VkAttachmentReference2KHR(
+    VulkanHandleMapping* handlemap,
+    VkAttachmentReference2KHR* toMap);
+
+void handlemap_VkSubpassDescription2KHR(
+    VulkanHandleMapping* handlemap,
+    VkSubpassDescription2KHR* toMap);
+
+void handlemap_VkSubpassDependency2KHR(
+    VulkanHandleMapping* handlemap,
+    VkSubpassDependency2KHR* toMap);
+
+void handlemap_VkRenderPassCreateInfo2KHR(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassCreateInfo2KHR* toMap);
+
+void handlemap_VkSubpassBeginInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkSubpassBeginInfoKHR* toMap);
+
+void handlemap_VkSubpassEndInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkSubpassEndInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void handlemap_VkSharedPresentSurfaceCapabilitiesKHR(
+    VulkanHandleMapping* handlemap,
+    VkSharedPresentSurfaceCapabilitiesKHR* toMap);
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void handlemap_VkImportFenceWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportFenceWin32HandleInfoKHR* toMap);
+
+void handlemap_VkExportFenceWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkExportFenceWin32HandleInfoKHR* toMap);
+
+void handlemap_VkFenceGetWin32HandleInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkFenceGetWin32HandleInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+void handlemap_VkImportFenceFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImportFenceFdInfoKHR* toMap);
+
+void handlemap_VkFenceGetFdInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkFenceGetFdInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void handlemap_VkPhysicalDeviceSurfaceInfo2KHR(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSurfaceInfo2KHR* toMap);
+
+void handlemap_VkSurfaceCapabilities2KHR(
+    VulkanHandleMapping* handlemap,
+    VkSurfaceCapabilities2KHR* toMap);
+
+void handlemap_VkSurfaceFormat2KHR(
+    VulkanHandleMapping* handlemap,
+    VkSurfaceFormat2KHR* toMap);
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void handlemap_VkDisplayProperties2KHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayProperties2KHR* toMap);
+
+void handlemap_VkDisplayPlaneProperties2KHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPlaneProperties2KHR* toMap);
+
+void handlemap_VkDisplayModeProperties2KHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayModeProperties2KHR* toMap);
+
+void handlemap_VkDisplayPlaneInfo2KHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPlaneInfo2KHR* toMap);
+
+void handlemap_VkDisplayPlaneCapabilities2KHR(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPlaneCapabilities2KHR* toMap);
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+void handlemap_VkImageFormatListCreateInfoKHR(
+    VulkanHandleMapping* handlemap,
+    VkImageFormatListCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+void handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDevice8BitStorageFeaturesKHR* toMap);
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void handlemap_VkNativeBufferANDROID(
+    VulkanHandleMapping* handlemap,
+    VkNativeBufferANDROID* toMap);
+
+#endif
+#ifdef VK_EXT_debug_report
+void handlemap_VkDebugReportCallbackCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugReportCallbackCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(
+    VulkanHandleMapping* handlemap,
+    VkPipelineRasterizationStateRasterizationOrderAMD* toMap);
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void handlemap_VkDebugMarkerObjectNameInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugMarkerObjectNameInfoEXT* toMap);
+
+void handlemap_VkDebugMarkerObjectTagInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugMarkerObjectTagInfoEXT* toMap);
+
+void handlemap_VkDebugMarkerMarkerInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugMarkerMarkerInfoEXT* toMap);
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void handlemap_VkDedicatedAllocationImageCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkDedicatedAllocationImageCreateInfoNV* toMap);
+
+void handlemap_VkDedicatedAllocationBufferCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkDedicatedAllocationBufferCreateInfoNV* toMap);
+
+void handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkDedicatedAllocationMemoryAllocateInfoNV* toMap);
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void handlemap_VkTextureLODGatherFormatPropertiesAMD(
+    VulkanHandleMapping* handlemap,
+    VkTextureLODGatherFormatPropertiesAMD* toMap);
+
+#endif
+#ifdef VK_AMD_shader_info
+void handlemap_VkShaderResourceUsageAMD(
+    VulkanHandleMapping* handlemap,
+    VkShaderResourceUsageAMD* toMap);
+
+void handlemap_VkShaderStatisticsInfoAMD(
+    VulkanHandleMapping* handlemap,
+    VkShaderStatisticsInfoAMD* toMap);
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void handlemap_VkExternalImageFormatPropertiesNV(
+    VulkanHandleMapping* handlemap,
+    VkExternalImageFormatPropertiesNV* toMap);
+
+#endif
+#ifdef VK_NV_external_memory
+void handlemap_VkExternalMemoryImageCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkExternalMemoryImageCreateInfoNV* toMap);
+
+void handlemap_VkExportMemoryAllocateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkExportMemoryAllocateInfoNV* toMap);
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void handlemap_VkImportMemoryWin32HandleInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkImportMemoryWin32HandleInfoNV* toMap);
+
+void handlemap_VkExportMemoryWin32HandleInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkExportMemoryWin32HandleInfoNV* toMap);
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkWin32KeyedMutexAcquireReleaseInfoNV* toMap);
+
+#endif
+#ifdef VK_EXT_validation_flags
+void handlemap_VkValidationFlagsEXT(
+    VulkanHandleMapping* handlemap,
+    VkValidationFlagsEXT* toMap);
+
+#endif
+#ifdef VK_NN_vi_surface
+void handlemap_VkViSurfaceCreateInfoNN(
+    VulkanHandleMapping* handlemap,
+    VkViSurfaceCreateInfoNN* toMap);
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void handlemap_VkConditionalRenderingBeginInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkConditionalRenderingBeginInfoEXT* toMap);
+
+void handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT* toMap);
+
+void handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkCommandBufferInheritanceConditionalRenderingInfoEXT* toMap);
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void handlemap_VkDeviceGeneratedCommandsFeaturesNVX(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGeneratedCommandsFeaturesNVX* toMap);
+
+void handlemap_VkDeviceGeneratedCommandsLimitsNVX(
+    VulkanHandleMapping* handlemap,
+    VkDeviceGeneratedCommandsLimitsNVX* toMap);
+
+void handlemap_VkIndirectCommandsTokenNVX(
+    VulkanHandleMapping* handlemap,
+    VkIndirectCommandsTokenNVX* toMap);
+
+void handlemap_VkIndirectCommandsLayoutTokenNVX(
+    VulkanHandleMapping* handlemap,
+    VkIndirectCommandsLayoutTokenNVX* toMap);
+
+void handlemap_VkIndirectCommandsLayoutCreateInfoNVX(
+    VulkanHandleMapping* handlemap,
+    VkIndirectCommandsLayoutCreateInfoNVX* toMap);
+
+void handlemap_VkCmdProcessCommandsInfoNVX(
+    VulkanHandleMapping* handlemap,
+    VkCmdProcessCommandsInfoNVX* toMap);
+
+void handlemap_VkCmdReserveSpaceForCommandsInfoNVX(
+    VulkanHandleMapping* handlemap,
+    VkCmdReserveSpaceForCommandsInfoNVX* toMap);
+
+void handlemap_VkObjectTableCreateInfoNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTableCreateInfoNVX* toMap);
+
+void handlemap_VkObjectTableEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTableEntryNVX* toMap);
+
+void handlemap_VkObjectTablePipelineEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTablePipelineEntryNVX* toMap);
+
+void handlemap_VkObjectTableDescriptorSetEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTableDescriptorSetEntryNVX* toMap);
+
+void handlemap_VkObjectTableVertexBufferEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTableVertexBufferEntryNVX* toMap);
+
+void handlemap_VkObjectTableIndexBufferEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTableIndexBufferEntryNVX* toMap);
+
+void handlemap_VkObjectTablePushConstantEntryNVX(
+    VulkanHandleMapping* handlemap,
+    VkObjectTablePushConstantEntryNVX* toMap);
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void handlemap_VkViewportWScalingNV(
+    VulkanHandleMapping* handlemap,
+    VkViewportWScalingNV* toMap);
+
+void handlemap_VkPipelineViewportWScalingStateCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkPipelineViewportWScalingStateCreateInfoNV* toMap);
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+void handlemap_VkSurfaceCapabilities2EXT(
+    VulkanHandleMapping* handlemap,
+    VkSurfaceCapabilities2EXT* toMap);
+
+#endif
+#ifdef VK_EXT_display_control
+void handlemap_VkDisplayPowerInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDisplayPowerInfoEXT* toMap);
+
+void handlemap_VkDeviceEventInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDeviceEventInfoEXT* toMap);
+
+void handlemap_VkDisplayEventInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDisplayEventInfoEXT* toMap);
+
+void handlemap_VkSwapchainCounterCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkSwapchainCounterCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+void handlemap_VkRefreshCycleDurationGOOGLE(
+    VulkanHandleMapping* handlemap,
+    VkRefreshCycleDurationGOOGLE* toMap);
+
+void handlemap_VkPastPresentationTimingGOOGLE(
+    VulkanHandleMapping* handlemap,
+    VkPastPresentationTimingGOOGLE* toMap);
+
+void handlemap_VkPresentTimeGOOGLE(
+    VulkanHandleMapping* handlemap,
+    VkPresentTimeGOOGLE* toMap);
+
+void handlemap_VkPresentTimesInfoGOOGLE(
+    VulkanHandleMapping* handlemap,
+    VkPresentTimesInfoGOOGLE* toMap);
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toMap);
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void handlemap_VkViewportSwizzleNV(
+    VulkanHandleMapping* handlemap,
+    VkViewportSwizzleNV* toMap);
+
+void handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkPipelineViewportSwizzleStateCreateInfoNV* toMap);
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT* toMap);
+
+void handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkPipelineDiscardRectangleStateCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toMap);
+
+void handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkPipelineRasterizationConservativeStateCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void handlemap_VkXYColorEXT(
+    VulkanHandleMapping* handlemap,
+    VkXYColorEXT* toMap);
+
+void handlemap_VkHdrMetadataEXT(
+    VulkanHandleMapping* handlemap,
+    VkHdrMetadataEXT* toMap);
+
+#endif
+#ifdef VK_MVK_ios_surface
+void handlemap_VkIOSSurfaceCreateInfoMVK(
+    VulkanHandleMapping* handlemap,
+    VkIOSSurfaceCreateInfoMVK* toMap);
+
+#endif
+#ifdef VK_MVK_macos_surface
+void handlemap_VkMacOSSurfaceCreateInfoMVK(
+    VulkanHandleMapping* handlemap,
+    VkMacOSSurfaceCreateInfoMVK* toMap);
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void handlemap_VkDebugUtilsObjectNameInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugUtilsObjectNameInfoEXT* toMap);
+
+void handlemap_VkDebugUtilsObjectTagInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugUtilsObjectTagInfoEXT* toMap);
+
+void handlemap_VkDebugUtilsLabelEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugUtilsLabelEXT* toMap);
+
+void handlemap_VkDebugUtilsMessengerCallbackDataEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugUtilsMessengerCallbackDataEXT* toMap);
+
+void handlemap_VkDebugUtilsMessengerCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDebugUtilsMessengerCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void handlemap_VkAndroidHardwareBufferUsageANDROID(
+    VulkanHandleMapping* handlemap,
+    VkAndroidHardwareBufferUsageANDROID* toMap);
+
+void handlemap_VkAndroidHardwareBufferPropertiesANDROID(
+    VulkanHandleMapping* handlemap,
+    VkAndroidHardwareBufferPropertiesANDROID* toMap);
+
+void handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(
+    VulkanHandleMapping* handlemap,
+    VkAndroidHardwareBufferFormatPropertiesANDROID* toMap);
+
+void handlemap_VkImportAndroidHardwareBufferInfoANDROID(
+    VulkanHandleMapping* handlemap,
+    VkImportAndroidHardwareBufferInfoANDROID* toMap);
+
+void handlemap_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+    VulkanHandleMapping* handlemap,
+    VkMemoryGetAndroidHardwareBufferInfoANDROID* toMap);
+
+void handlemap_VkExternalFormatANDROID(
+    VulkanHandleMapping* handlemap,
+    VkExternalFormatANDROID* toMap);
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void handlemap_VkSamplerReductionModeCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkSamplerReductionModeCreateInfoEXT* toMap);
+
+void handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* toMap);
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void handlemap_VkSampleLocationEXT(
+    VulkanHandleMapping* handlemap,
+    VkSampleLocationEXT* toMap);
+
+void handlemap_VkSampleLocationsInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkSampleLocationsInfoEXT* toMap);
+
+void handlemap_VkAttachmentSampleLocationsEXT(
+    VulkanHandleMapping* handlemap,
+    VkAttachmentSampleLocationsEXT* toMap);
+
+void handlemap_VkSubpassSampleLocationsEXT(
+    VulkanHandleMapping* handlemap,
+    VkSubpassSampleLocationsEXT* toMap);
+
+void handlemap_VkRenderPassSampleLocationsBeginInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkRenderPassSampleLocationsBeginInfoEXT* toMap);
+
+void handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkPipelineSampleLocationsStateCreateInfoEXT* toMap);
+
+void handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceSampleLocationsPropertiesEXT* toMap);
+
+void handlemap_VkMultisamplePropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkMultisamplePropertiesEXT* toMap);
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toMap);
+
+void handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkPipelineColorBlendAdvancedStateCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void handlemap_VkPipelineCoverageToColorStateCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkPipelineCoverageToColorStateCreateInfoNV* toMap);
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void handlemap_VkPipelineCoverageModulationStateCreateInfoNV(
+    VulkanHandleMapping* handlemap,
+    VkPipelineCoverageModulationStateCreateInfoNV* toMap);
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void handlemap_VkValidationCacheCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkValidationCacheCreateInfoEXT* toMap);
+
+void handlemap_VkShaderModuleValidationCacheCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkShaderModuleValidationCacheCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* toMap);
+
+void handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceDescriptorIndexingFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceDescriptorIndexingPropertiesEXT* toMap);
+
+void handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* toMap);
+
+void handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+    VulkanHandleMapping* handlemap,
+    VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* toMap);
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void handlemap_VkImportMemoryHostPointerInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkImportMemoryHostPointerInfoEXT* toMap);
+
+void handlemap_VkMemoryHostPointerPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkMemoryHostPointerPropertiesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toMap);
+
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+void handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceShaderCorePropertiesAMD* toMap);
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toMap);
+
+void handlemap_VkVertexInputBindingDivisorDescriptionEXT(
+    VulkanHandleMapping* handlemap,
+    VkVertexInputBindingDivisorDescriptionEXT* toMap);
+
+void handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+    VulkanHandleMapping* handlemap,
+    VkPipelineVertexInputDivisorStateCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void handlemap_VkQueueFamilyCheckpointPropertiesNV(
+    VulkanHandleMapping* handlemap,
+    VkQueueFamilyCheckpointPropertiesNV* toMap);
+
+void handlemap_VkCheckpointDataNV(
+    VulkanHandleMapping* handlemap,
+    VkCheckpointDataNV* toMap);
+
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
new file mode 100644
index 0000000..1bd5dae
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -0,0 +1,14669 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_marshaling_guest
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "goldfish_vk_marshaling_guest.h"
+
+
+#include "goldfish_vk_extension_structs_guest.h"
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+void marshal_extension_struct(
+    VulkanStream* vkStream,
+    const void* structExtension);
+
+void unmarshal_extension_struct(
+    VulkanStream* vkStream,
+    void* structExtension_out);
+
+#ifdef VK_VERSION_1_0
+void marshal_VkApplicationInfo(
+    VulkanStream* vkStream,
+    const VkApplicationInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->putString(forMarshaling->pApplicationName);
+    vkStream->write((uint32_t*)&forMarshaling->applicationVersion, sizeof(uint32_t));
+    vkStream->putString(forMarshaling->pEngineName);
+    vkStream->write((uint32_t*)&forMarshaling->engineVersion, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
+}
+
+void unmarshal_VkApplicationInfo(
+    VulkanStream* vkStream,
+    VkApplicationInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->loadStringInPlace((char**)&forUnmarshaling->pApplicationName);
+    vkStream->read((uint32_t*)&forUnmarshaling->applicationVersion, sizeof(uint32_t));
+    vkStream->loadStringInPlace((char**)&forUnmarshaling->pEngineName);
+    vkStream->read((uint32_t*)&forUnmarshaling->engineVersion, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
+}
+
+void marshal_VkInstanceCreateInfo(
+    VulkanStream* vkStream,
+    const VkInstanceCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkInstanceCreateFlags*)&forMarshaling->flags, sizeof(VkInstanceCreateFlags));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pApplicationInfo;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pApplicationInfo)
+    {
+        marshal_VkApplicationInfo(vkStream, (const VkApplicationInfo*)(forMarshaling->pApplicationInfo));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
+    saveStringArray(vkStream, forMarshaling->ppEnabledLayerNames, forMarshaling->enabledLayerCount);
+    vkStream->write((uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
+    saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames, forMarshaling->enabledExtensionCount);
+}
+
+void unmarshal_VkInstanceCreateInfo(
+    VulkanStream* vkStream,
+    VkInstanceCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkInstanceCreateFlags*)&forUnmarshaling->flags, sizeof(VkInstanceCreateFlags));
+    // WARNING PTR CHECK
+    forUnmarshaling->pApplicationInfo = (const VkApplicationInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pApplicationInfo)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pApplicationInfo, sizeof(const VkApplicationInfo));
+        unmarshal_VkApplicationInfo(vkStream, (VkApplicationInfo*)(forUnmarshaling->pApplicationInfo));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->enabledLayerCount, sizeof(uint32_t));
+    vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledLayerNames);
+    vkStream->read((uint32_t*)&forUnmarshaling->enabledExtensionCount, sizeof(uint32_t));
+    vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledExtensionNames);
+}
+
+void marshal_VkAllocationCallbacks(
+    VulkanStream* vkStream,
+    const VkAllocationCallbacks* forMarshaling)
+{
+    // WARNING PTR CHECK
+    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+    vkStream->putBe64(cgen_var_2);
+    if (forMarshaling->pUserData)
+    {
+        vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
+    }
+    uint64_t cgen_var_3 = (uint64_t)forMarshaling->pfnAllocation;
+    vkStream->putBe64(cgen_var_3);
+    uint64_t cgen_var_4 = (uint64_t)forMarshaling->pfnReallocation;
+    vkStream->putBe64(cgen_var_4);
+    uint64_t cgen_var_5 = (uint64_t)forMarshaling->pfnFree;
+    vkStream->putBe64(cgen_var_5);
+    uint64_t cgen_var_6 = (uint64_t)forMarshaling->pfnInternalAllocation;
+    vkStream->putBe64(cgen_var_6);
+    uint64_t cgen_var_7 = (uint64_t)forMarshaling->pfnInternalFree;
+    vkStream->putBe64(cgen_var_7);
+}
+
+void unmarshal_VkAllocationCallbacks(
+    VulkanStream* vkStream,
+    VkAllocationCallbacks* forUnmarshaling)
+{
+    // WARNING PTR CHECK
+    forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pUserData)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
+        vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
+    }
+    forUnmarshaling->pfnAllocation = (PFN_vkAllocationFunction)vkStream->getBe64();
+    forUnmarshaling->pfnReallocation = (PFN_vkReallocationFunction)vkStream->getBe64();
+    forUnmarshaling->pfnFree = (PFN_vkFreeFunction)vkStream->getBe64();
+    forUnmarshaling->pfnInternalAllocation = (PFN_vkInternalAllocationNotification)vkStream->getBe64();
+    forUnmarshaling->pfnInternalFree = (PFN_vkInternalFreeNotification)vkStream->getBe64();
+}
+
+void marshal_VkPhysicalDeviceFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceFeatures* forMarshaling)
+{
+    vkStream->write((VkBool32*)&forMarshaling->robustBufferAccess, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->fullDrawIndexUint32, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->imageCubeArray, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->independentBlend, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->geometryShader, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->tessellationShader, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sampleRateShading, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->dualSrcBlend, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->logicOp, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->multiDrawIndirect, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->drawIndirectFirstInstance, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->depthClamp, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->depthBiasClamp, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->fillModeNonSolid, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->depthBounds, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->wideLines, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->largePoints, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->alphaToOne, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->multiViewport, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->samplerAnisotropy, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->textureCompressionETC2, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->textureCompressionASTC_LDR, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->textureCompressionBC, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->occlusionQueryPrecise, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->pipelineStatisticsQuery, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->vertexPipelineStoresAndAtomics, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->fragmentStoresAndAtomics, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderTessellationAndGeometryPointSize, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderImageGatherExtended, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageExtendedFormats, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageMultisample, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageReadWithoutFormat, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageWriteWithoutFormat, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderClipDistance, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderCullDistance, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderFloat64, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderInt64, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderInt16, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderResourceResidency, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderResourceMinLod, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sparseBinding, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sparseResidencyBuffer, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sparseResidencyImage2D, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sparseResidencyImage3D, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sparseResidency2Samples, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sparseResidency4Samples, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sparseResidency8Samples, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sparseResidency16Samples, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sparseResidencyAliased, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->variableMultisampleRate, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->inheritedQueries, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceFeatures* forUnmarshaling)
+{
+    vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccess, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->fullDrawIndexUint32, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->imageCubeArray, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->independentBlend, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->geometryShader, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->tessellationShader, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sampleRateShading, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->dualSrcBlend, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->logicOp, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->multiDrawIndirect, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->drawIndirectFirstInstance, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthClamp, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthBiasClamp, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->fillModeNonSolid, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthBounds, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->wideLines, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->largePoints, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->alphaToOne, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->multiViewport, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->samplerAnisotropy, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionETC2, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionASTC_LDR, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionBC, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->occlusionQueryPrecise, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->pipelineStatisticsQuery, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->vertexPipelineStoresAndAtomics, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->fragmentStoresAndAtomics, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderTessellationAndGeometryPointSize, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderImageGatherExtended, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageExtendedFormats, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageMultisample, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageReadWithoutFormat, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageWriteWithoutFormat, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderClipDistance, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderCullDistance, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderFloat64, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderInt64, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderInt16, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderResourceResidency, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderResourceMinLod, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sparseBinding, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyBuffer, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyImage2D, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyImage3D, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency2Samples, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency4Samples, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency8Samples, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency16Samples, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyAliased, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->variableMultisampleRate, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->inheritedQueries, sizeof(VkBool32));
+}
+
+void marshal_VkFormatProperties(
+    VulkanStream* vkStream,
+    const VkFormatProperties* forMarshaling)
+{
+    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags));
+    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags));
+    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->bufferFeatures, sizeof(VkFormatFeatureFlags));
+}
+
+void unmarshal_VkFormatProperties(
+    VulkanStream* vkStream,
+    VkFormatProperties* forUnmarshaling)
+{
+    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags));
+    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags));
+    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->bufferFeatures, sizeof(VkFormatFeatureFlags));
+}
+
+void marshal_VkExtent3D(
+    VulkanStream* vkStream,
+    const VkExtent3D* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->depth, sizeof(uint32_t));
+}
+
+void unmarshal_VkExtent3D(
+    VulkanStream* vkStream,
+    VkExtent3D* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->depth, sizeof(uint32_t));
+}
+
+void marshal_VkImageFormatProperties(
+    VulkanStream* vkStream,
+    const VkImageFormatProperties* forMarshaling)
+{
+    marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->maxExtent));
+    vkStream->write((uint32_t*)&forMarshaling->maxMipLevels, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxArrayLayers, sizeof(uint32_t));
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->write((VkDeviceSize*)&forMarshaling->maxResourceSize, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkImageFormatProperties(
+    VulkanStream* vkStream,
+    VkImageFormatProperties* forUnmarshaling)
+{
+    unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->maxExtent));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMipLevels, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxArrayLayers, sizeof(uint32_t));
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxResourceSize, sizeof(VkDeviceSize));
+}
+
+void marshal_VkPhysicalDeviceLimits(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceLimits* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->maxImageDimension1D, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxImageDimension2D, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxImageDimension3D, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxImageDimensionCube, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTexelBufferElements, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxUniformBufferRange, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStorageBufferRange, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPushConstantsSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMemoryAllocationCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxSamplerAllocationCount, sizeof(uint32_t));
+    vkStream->write((VkDeviceSize*)&forMarshaling->bufferImageGranularity, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->sparseAddressSpaceSize, sizeof(VkDeviceSize));
+    vkStream->write((uint32_t*)&forMarshaling->maxBoundDescriptorSets, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorSamplers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUniformBuffers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorStorageBuffers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorSampledImages, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorStorageImages, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInputAttachments, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageResources, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSamplers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffersDynamic, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffersDynamic, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSampledImages, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageImages, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInputAttachments, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxVertexInputAttributes, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxVertexInputBindings, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxVertexInputAttributeOffset, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxVertexInputBindingStride, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxVertexOutputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTessellationGenerationLevel, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTessellationPatchSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerVertexInputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerVertexOutputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerPatchOutputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlTotalOutputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTessellationEvaluationInputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTessellationEvaluationOutputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxGeometryShaderInvocations, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxGeometryInputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxGeometryOutputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxGeometryOutputVertices, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxGeometryTotalOutputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxFragmentInputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxFragmentOutputAttachments, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxFragmentDualSrcAttachments, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxFragmentCombinedOutputResources, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxComputeSharedMemorySize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)forMarshaling->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxComputeWorkGroupInvocations, sizeof(uint32_t));
+    vkStream->write((uint32_t*)forMarshaling->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->subPixelPrecisionBits, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->subTexelPrecisionBits, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->mipmapPrecisionBits, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDrawIndexedIndexValue, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDrawIndirectCount, sizeof(uint32_t));
+    vkStream->write((float*)&forMarshaling->maxSamplerLodBias, sizeof(float));
+    vkStream->write((float*)&forMarshaling->maxSamplerAnisotropy, sizeof(float));
+    vkStream->write((uint32_t*)&forMarshaling->maxViewports, sizeof(uint32_t));
+    vkStream->write((uint32_t*)forMarshaling->maxViewportDimensions, 2 * sizeof(uint32_t));
+    vkStream->write((float*)forMarshaling->viewportBoundsRange, 2 * sizeof(float));
+    vkStream->write((uint32_t*)&forMarshaling->viewportSubPixelBits, sizeof(uint32_t));
+    uint64_t cgen_var_14 = (uint64_t)forMarshaling->minMemoryMapAlignment;
+    vkStream->putBe64(cgen_var_14);
+    vkStream->write((VkDeviceSize*)&forMarshaling->minTexelBufferOffsetAlignment, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->minUniformBufferOffsetAlignment, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->minStorageBufferOffsetAlignment, sizeof(VkDeviceSize));
+    vkStream->write((int32_t*)&forMarshaling->minTexelOffset, sizeof(int32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTexelOffset, sizeof(uint32_t));
+    vkStream->write((int32_t*)&forMarshaling->minTexelGatherOffset, sizeof(int32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTexelGatherOffset, sizeof(uint32_t));
+    vkStream->write((float*)&forMarshaling->minInterpolationOffset, sizeof(float));
+    vkStream->write((float*)&forMarshaling->maxInterpolationOffset, sizeof(float));
+    vkStream->write((uint32_t*)&forMarshaling->subPixelInterpolationOffsetBits, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxFramebufferWidth, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxFramebufferHeight, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxFramebufferLayers, sizeof(uint32_t));
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferColorSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferDepthSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferStencilSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferNoAttachmentsSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->write((uint32_t*)&forMarshaling->maxColorAttachments, sizeof(uint32_t));
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageColorSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageIntegerSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageDepthSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageStencilSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->storageImageSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->write((uint32_t*)&forMarshaling->maxSampleMaskWords, sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->timestampComputeAndGraphics, sizeof(VkBool32));
+    vkStream->write((float*)&forMarshaling->timestampPeriod, sizeof(float));
+    vkStream->write((uint32_t*)&forMarshaling->maxClipDistances, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxCullDistances, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxCombinedClipAndCullDistances, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->discreteQueuePriorities, sizeof(uint32_t));
+    vkStream->write((float*)forMarshaling->pointSizeRange, 2 * sizeof(float));
+    vkStream->write((float*)forMarshaling->lineWidthRange, 2 * sizeof(float));
+    vkStream->write((float*)&forMarshaling->pointSizeGranularity, sizeof(float));
+    vkStream->write((float*)&forMarshaling->lineWidthGranularity, sizeof(float));
+    vkStream->write((VkBool32*)&forMarshaling->strictLines, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->standardSampleLocations, sizeof(VkBool32));
+    vkStream->write((VkDeviceSize*)&forMarshaling->optimalBufferCopyOffsetAlignment, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->optimalBufferCopyRowPitchAlignment, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->nonCoherentAtomSize, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkPhysicalDeviceLimits(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceLimits* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimension1D, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimension2D, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimension3D, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimensionCube, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTexelBufferElements, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxUniformBufferRange, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStorageBufferRange, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPushConstantsSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMemoryAllocationCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxSamplerAllocationCount, sizeof(uint32_t));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->bufferImageGranularity, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->sparseAddressSpaceSize, sizeof(VkDeviceSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxBoundDescriptorSets, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorSamplers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUniformBuffers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorStorageBuffers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorSampledImages, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorStorageImages, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInputAttachments, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageResources, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSamplers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUniformBuffers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUniformBuffersDynamic, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageBuffers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageBuffersDynamic, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSampledImages, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageImages, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInputAttachments, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputAttributes, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputBindings, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputAttributeOffset, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputBindingStride, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexOutputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationGenerationLevel, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationPatchSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerVertexInputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerVertexOutputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerPatchOutputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlTotalOutputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationEvaluationInputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationEvaluationOutputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryShaderInvocations, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryInputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryOutputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryOutputVertices, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryTotalOutputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentInputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentOutputAttachments, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentDualSrcAttachments, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentCombinedOutputResources, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxComputeSharedMemorySize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxComputeWorkGroupInvocations, sizeof(uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->subPixelPrecisionBits, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->subTexelPrecisionBits, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->mipmapPrecisionBits, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDrawIndexedIndexValue, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDrawIndirectCount, sizeof(uint32_t));
+    vkStream->read((float*)&forUnmarshaling->maxSamplerLodBias, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->maxSamplerAnisotropy, sizeof(float));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxViewports, sizeof(uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->maxViewportDimensions, 2 * sizeof(uint32_t));
+    vkStream->read((float*)forUnmarshaling->viewportBoundsRange, 2 * sizeof(float));
+    vkStream->read((uint32_t*)&forUnmarshaling->viewportSubPixelBits, sizeof(uint32_t));
+    forUnmarshaling->minMemoryMapAlignment = (size_t)vkStream->getBe64();
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->minTexelBufferOffsetAlignment, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->minUniformBufferOffsetAlignment, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->minStorageBufferOffsetAlignment, sizeof(VkDeviceSize));
+    vkStream->read((int32_t*)&forUnmarshaling->minTexelOffset, sizeof(int32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTexelOffset, sizeof(uint32_t));
+    vkStream->read((int32_t*)&forUnmarshaling->minTexelGatherOffset, sizeof(int32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTexelGatherOffset, sizeof(uint32_t));
+    vkStream->read((float*)&forUnmarshaling->minInterpolationOffset, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->maxInterpolationOffset, sizeof(float));
+    vkStream->read((uint32_t*)&forUnmarshaling->subPixelInterpolationOffsetBits, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferWidth, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferHeight, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferLayers, sizeof(uint32_t));
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferColorSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferDepthSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferStencilSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferNoAttachmentsSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxColorAttachments, sizeof(uint32_t));
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageColorSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageIntegerSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageDepthSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageStencilSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->storageImageSampleCounts, sizeof(VkSampleCountFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxSampleMaskWords, sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->timestampComputeAndGraphics, sizeof(VkBool32));
+    vkStream->read((float*)&forUnmarshaling->timestampPeriod, sizeof(float));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxClipDistances, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxCullDistances, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxCombinedClipAndCullDistances, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->discreteQueuePriorities, sizeof(uint32_t));
+    vkStream->read((float*)forUnmarshaling->pointSizeRange, 2 * sizeof(float));
+    vkStream->read((float*)forUnmarshaling->lineWidthRange, 2 * sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->pointSizeGranularity, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->lineWidthGranularity, sizeof(float));
+    vkStream->read((VkBool32*)&forUnmarshaling->strictLines, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->standardSampleLocations, sizeof(VkBool32));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->optimalBufferCopyOffsetAlignment, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->optimalBufferCopyRowPitchAlignment, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->nonCoherentAtomSize, sizeof(VkDeviceSize));
+}
+
+void marshal_VkPhysicalDeviceSparseProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSparseProperties* forMarshaling)
+{
+    vkStream->write((VkBool32*)&forMarshaling->residencyStandard2DBlockShape, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->residencyStandard2DMultisampleBlockShape, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->residencyStandard3DBlockShape, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->residencyAlignedMipSize, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->residencyNonResidentStrict, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSparseProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSparseProperties* forUnmarshaling)
+{
+    vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard2DBlockShape, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard2DMultisampleBlockShape, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard3DBlockShape, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->residencyAlignedMipSize, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->residencyNonResidentStrict, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceProperties* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->driverVersion, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->deviceID, sizeof(uint32_t));
+    vkStream->write((VkPhysicalDeviceType*)&forMarshaling->deviceType, sizeof(VkPhysicalDeviceType));
+    vkStream->write((char*)forMarshaling->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
+    vkStream->write((uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    marshal_VkPhysicalDeviceLimits(vkStream, (VkPhysicalDeviceLimits*)(&forMarshaling->limits));
+    marshal_VkPhysicalDeviceSparseProperties(vkStream, (VkPhysicalDeviceSparseProperties*)(&forMarshaling->sparseProperties));
+}
+
+void unmarshal_VkPhysicalDeviceProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceProperties* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->driverVersion, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->vendorID, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceID, sizeof(uint32_t));
+    vkStream->read((VkPhysicalDeviceType*)&forUnmarshaling->deviceType, sizeof(VkPhysicalDeviceType));
+    vkStream->read((char*)forUnmarshaling->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
+    vkStream->read((uint8_t*)forUnmarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    unmarshal_VkPhysicalDeviceLimits(vkStream, (VkPhysicalDeviceLimits*)(&forUnmarshaling->limits));
+    unmarshal_VkPhysicalDeviceSparseProperties(vkStream, (VkPhysicalDeviceSparseProperties*)(&forUnmarshaling->sparseProperties));
+}
+
+void marshal_VkQueueFamilyProperties(
+    VulkanStream* vkStream,
+    const VkQueueFamilyProperties* forMarshaling)
+{
+    vkStream->write((VkQueueFlags*)&forMarshaling->queueFlags, sizeof(VkQueueFlags));
+    vkStream->write((uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->timestampValidBits, sizeof(uint32_t));
+    marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->minImageTransferGranularity));
+}
+
+void unmarshal_VkQueueFamilyProperties(
+    VulkanStream* vkStream,
+    VkQueueFamilyProperties* forUnmarshaling)
+{
+    vkStream->read((VkQueueFlags*)&forUnmarshaling->queueFlags, sizeof(VkQueueFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->queueCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->timestampValidBits, sizeof(uint32_t));
+    unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->minImageTransferGranularity));
+}
+
+void marshal_VkMemoryType(
+    VulkanStream* vkStream,
+    const VkMemoryType* forMarshaling)
+{
+    vkStream->write((VkMemoryPropertyFlags*)&forMarshaling->propertyFlags, sizeof(VkMemoryPropertyFlags));
+    vkStream->write((uint32_t*)&forMarshaling->heapIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryType(
+    VulkanStream* vkStream,
+    VkMemoryType* forUnmarshaling)
+{
+    vkStream->read((VkMemoryPropertyFlags*)&forUnmarshaling->propertyFlags, sizeof(VkMemoryPropertyFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->heapIndex, sizeof(uint32_t));
+}
+
+void marshal_VkMemoryHeap(
+    VulkanStream* vkStream,
+    const VkMemoryHeap* forMarshaling)
+{
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+    vkStream->write((VkMemoryHeapFlags*)&forMarshaling->flags, sizeof(VkMemoryHeapFlags));
+}
+
+void unmarshal_VkMemoryHeap(
+    VulkanStream* vkStream,
+    VkMemoryHeap* forUnmarshaling)
+{
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+    vkStream->read((VkMemoryHeapFlags*)&forUnmarshaling->flags, sizeof(VkMemoryHeapFlags));
+}
+
+void marshal_VkPhysicalDeviceMemoryProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMemoryProperties* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->memoryTypeCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
+    {
+        marshal_VkMemoryType(vkStream, (VkMemoryType*)(forMarshaling->memoryTypes + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->memoryHeapCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
+    {
+        marshal_VkMemoryHeap(vkStream, (VkMemoryHeap*)(forMarshaling->memoryHeaps + i));
+    }
+}
+
+void unmarshal_VkPhysicalDeviceMemoryProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMemoryProperties* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
+    {
+        unmarshal_VkMemoryType(vkStream, (VkMemoryType*)(forUnmarshaling->memoryTypes + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryHeapCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
+    {
+        unmarshal_VkMemoryHeap(vkStream, (VkMemoryHeap*)(forUnmarshaling->memoryHeaps + i));
+    }
+}
+
+void marshal_VkDeviceQueueCreateInfo(
+    VulkanStream* vkStream,
+    const VkDeviceQueueCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDeviceQueueCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceQueueCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
+    vkStream->write((const float*)forMarshaling->pQueuePriorities, forMarshaling->queueCount * sizeof(const float));
+}
+
+void unmarshal_VkDeviceQueueCreateInfo(
+    VulkanStream* vkStream,
+    VkDeviceQueueCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceQueueCreateFlags*)&forUnmarshaling->flags, sizeof(VkDeviceQueueCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->queueCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pQueuePriorities, forUnmarshaling->queueCount * sizeof(const float));
+    vkStream->read((float*)forUnmarshaling->pQueuePriorities, forUnmarshaling->queueCount * sizeof(const float));
+}
+
+void marshal_VkDeviceCreateInfo(
+    VulkanStream* vkStream,
+    const VkDeviceCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDeviceCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->queueCreateInfoCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueCreateInfoCount; ++i)
+    {
+        marshal_VkDeviceQueueCreateInfo(vkStream, (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
+    saveStringArray(vkStream, forMarshaling->ppEnabledLayerNames, forMarshaling->enabledLayerCount);
+    vkStream->write((uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
+    saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames, forMarshaling->enabledExtensionCount);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_16 = (uint64_t)(uintptr_t)forMarshaling->pEnabledFeatures;
+    vkStream->putBe64(cgen_var_16);
+    if (forMarshaling->pEnabledFeatures)
+    {
+        marshal_VkPhysicalDeviceFeatures(vkStream, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures));
+    }
+}
+
+void unmarshal_VkDeviceCreateInfo(
+    VulkanStream* vkStream,
+    VkDeviceCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceCreateFlags*)&forUnmarshaling->flags, sizeof(VkDeviceCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->queueCreateInfoCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pQueueCreateInfos, forUnmarshaling->queueCreateInfoCount * sizeof(const VkDeviceQueueCreateInfo));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueCreateInfoCount; ++i)
+    {
+        unmarshal_VkDeviceQueueCreateInfo(vkStream, (VkDeviceQueueCreateInfo*)(forUnmarshaling->pQueueCreateInfos + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->enabledLayerCount, sizeof(uint32_t));
+    vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledLayerNames);
+    vkStream->read((uint32_t*)&forUnmarshaling->enabledExtensionCount, sizeof(uint32_t));
+    vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledExtensionNames);
+    // WARNING PTR CHECK
+    forUnmarshaling->pEnabledFeatures = (const VkPhysicalDeviceFeatures*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pEnabledFeatures)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pEnabledFeatures, sizeof(const VkPhysicalDeviceFeatures));
+        unmarshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(forUnmarshaling->pEnabledFeatures));
+    }
+}
+
+void marshal_VkExtensionProperties(
+    VulkanStream* vkStream,
+    const VkExtensionProperties* forMarshaling)
+{
+    vkStream->write((char*)forMarshaling->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    vkStream->write((uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
+}
+
+void unmarshal_VkExtensionProperties(
+    VulkanStream* vkStream,
+    VkExtensionProperties* forUnmarshaling)
+{
+    vkStream->read((char*)forUnmarshaling->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    vkStream->read((uint32_t*)&forUnmarshaling->specVersion, sizeof(uint32_t));
+}
+
+void marshal_VkLayerProperties(
+    VulkanStream* vkStream,
+    const VkLayerProperties* forMarshaling)
+{
+    vkStream->write((char*)forMarshaling->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    vkStream->write((uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->implementationVersion, sizeof(uint32_t));
+    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+}
+
+void unmarshal_VkLayerProperties(
+    VulkanStream* vkStream,
+    VkLayerProperties* forUnmarshaling)
+{
+    vkStream->read((char*)forUnmarshaling->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    vkStream->read((uint32_t*)&forUnmarshaling->specVersion, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->implementationVersion, sizeof(uint32_t));
+    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+}
+
+void marshal_VkSubmitInfo(
+    VulkanStream* vkStream,
+    const VkSubmitInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
+    if (forMarshaling->waitSemaphoreCount)
+    {
+        uint64_t* cgen_var_18;
+        vkStream->alloc((void**)&cgen_var_18, forMarshaling->waitSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_18, forMarshaling->waitSemaphoreCount);
+        vkStream->write((uint64_t*)cgen_var_18, forMarshaling->waitSemaphoreCount * 8);
+    }
+    vkStream->write((const VkPipelineStageFlags*)forMarshaling->pWaitDstStageMask, forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+    vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
+    if (forMarshaling->commandBufferCount)
+    {
+        uint64_t* cgen_var_19;
+        vkStream->alloc((void**)&cgen_var_19, forMarshaling->commandBufferCount * 8);
+        vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(forMarshaling->pCommandBuffers, cgen_var_19, forMarshaling->commandBufferCount);
+        vkStream->write((uint64_t*)cgen_var_19, forMarshaling->commandBufferCount * 8);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
+    if (forMarshaling->signalSemaphoreCount)
+    {
+        uint64_t* cgen_var_20;
+        vkStream->alloc((void**)&cgen_var_20, forMarshaling->signalSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSignalSemaphores, cgen_var_20, forMarshaling->signalSemaphoreCount);
+        vkStream->write((uint64_t*)cgen_var_20, forMarshaling->signalSemaphoreCount * 8);
+    }
+}
+
+void unmarshal_VkSubmitInfo(
+    VulkanStream* vkStream,
+    VkSubmitInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount * sizeof(const VkSemaphore));
+    if (forUnmarshaling->waitSemaphoreCount)
+    {
+        uint64_t* cgen_var_21;
+        vkStream->alloc((void**)&cgen_var_21, forUnmarshaling->waitSemaphoreCount * 8);
+        vkStream->read((uint64_t*)cgen_var_21, forUnmarshaling->waitSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_21, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pWaitDstStageMask, forUnmarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+    vkStream->read((VkPipelineStageFlags*)forUnmarshaling->pWaitDstStageMask, forUnmarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pCommandBuffers, forUnmarshaling->commandBufferCount * sizeof(const VkCommandBuffer));
+    if (forUnmarshaling->commandBufferCount)
+    {
+        uint64_t* cgen_var_22;
+        vkStream->alloc((void**)&cgen_var_22, forUnmarshaling->commandBufferCount * 8);
+        vkStream->read((uint64_t*)cgen_var_22, forUnmarshaling->commandBufferCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_22, (VkCommandBuffer*)forUnmarshaling->pCommandBuffers, forUnmarshaling->commandBufferCount);
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount * sizeof(const VkSemaphore));
+    if (forUnmarshaling->signalSemaphoreCount)
+    {
+        uint64_t* cgen_var_23;
+        vkStream->alloc((void**)&cgen_var_23, forUnmarshaling->signalSemaphoreCount * 8);
+        vkStream->read((uint64_t*)cgen_var_23, forUnmarshaling->signalSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_23, (VkSemaphore*)forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount);
+    }
+}
+
+void marshal_VkMemoryAllocateInfo(
+    VulkanStream* vkStream,
+    const VkMemoryAllocateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
+    vkStream->write((uint32_t*)&forMarshaling->memoryTypeIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryAllocateInfo(
+    VulkanStream* vkStream,
+    VkMemoryAllocateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->allocationSize, sizeof(VkDeviceSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeIndex, sizeof(uint32_t));
+}
+
+void marshal_VkMappedMemoryRange(
+    VulkanStream* vkStream,
+    const VkMappedMemoryRange* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_24;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_24, 1);
+    vkStream->write((uint64_t*)&cgen_var_24, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkMappedMemoryRange(
+    VulkanStream* vkStream,
+    VkMappedMemoryRange* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_25;
+    vkStream->read((uint64_t*)&cgen_var_25, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_25, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkMemoryRequirements(
+    VulkanStream* vkStream,
+    const VkMemoryRequirements* forMarshaling)
+{
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->alignment, sizeof(VkDeviceSize));
+    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryRequirements(
+    VulkanStream* vkStream,
+    VkMemoryRequirements* forUnmarshaling)
+{
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->alignment, sizeof(VkDeviceSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkSparseImageFormatProperties(
+    VulkanStream* vkStream,
+    const VkSparseImageFormatProperties* forMarshaling)
+{
+    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+    marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->imageGranularity));
+    vkStream->write((VkSparseImageFormatFlags*)&forMarshaling->flags, sizeof(VkSparseImageFormatFlags));
+}
+
+void unmarshal_VkSparseImageFormatProperties(
+    VulkanStream* vkStream,
+    VkSparseImageFormatProperties* forUnmarshaling)
+{
+    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
+    unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->imageGranularity));
+    vkStream->read((VkSparseImageFormatFlags*)&forUnmarshaling->flags, sizeof(VkSparseImageFormatFlags));
+}
+
+void marshal_VkSparseImageMemoryRequirements(
+    VulkanStream* vkStream,
+    const VkSparseImageMemoryRequirements* forMarshaling)
+{
+    marshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forMarshaling->formatProperties));
+    vkStream->write((uint32_t*)&forMarshaling->imageMipTailFirstLod, sizeof(uint32_t));
+    vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailSize, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailOffset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailStride, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkSparseImageMemoryRequirements(
+    VulkanStream* vkStream,
+    VkSparseImageMemoryRequirements* forUnmarshaling)
+{
+    unmarshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forUnmarshaling->formatProperties));
+    vkStream->read((uint32_t*)&forUnmarshaling->imageMipTailFirstLod, sizeof(uint32_t));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailSize, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailOffset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailStride, sizeof(VkDeviceSize));
+}
+
+void marshal_VkSparseMemoryBind(
+    VulkanStream* vkStream,
+    const VkSparseMemoryBind* forMarshaling)
+{
+    vkStream->write((VkDeviceSize*)&forMarshaling->resourceOffset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+    uint64_t cgen_var_26;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_26, 1);
+    vkStream->write((uint64_t*)&cgen_var_26, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
+    vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+}
+
+void unmarshal_VkSparseMemoryBind(
+    VulkanStream* vkStream,
+    VkSparseMemoryBind* forUnmarshaling)
+{
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->resourceOffset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+    uint64_t cgen_var_27;
+    vkStream->read((uint64_t*)&cgen_var_27, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_27, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
+    vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+}
+
+void marshal_VkSparseBufferMemoryBindInfo(
+    VulkanStream* vkStream,
+    const VkSparseBufferMemoryBindInfo* forMarshaling)
+{
+    uint64_t cgen_var_28;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_28, 1);
+    vkStream->write((uint64_t*)&cgen_var_28, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
+    {
+        marshal_VkSparseMemoryBind(vkStream, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
+    }
+}
+
+void unmarshal_VkSparseBufferMemoryBindInfo(
+    VulkanStream* vkStream,
+    VkSparseBufferMemoryBindInfo* forUnmarshaling)
+{
+    uint64_t cgen_var_29;
+    vkStream->read((uint64_t*)&cgen_var_29, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_29, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pBinds, forUnmarshaling->bindCount * sizeof(const VkSparseMemoryBind));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
+    {
+        unmarshal_VkSparseMemoryBind(vkStream, (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
+    }
+}
+
+void marshal_VkSparseImageOpaqueMemoryBindInfo(
+    VulkanStream* vkStream,
+    const VkSparseImageOpaqueMemoryBindInfo* forMarshaling)
+{
+    uint64_t cgen_var_30;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_30, 1);
+    vkStream->write((uint64_t*)&cgen_var_30, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
+    {
+        marshal_VkSparseMemoryBind(vkStream, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
+    }
+}
+
+void unmarshal_VkSparseImageOpaqueMemoryBindInfo(
+    VulkanStream* vkStream,
+    VkSparseImageOpaqueMemoryBindInfo* forUnmarshaling)
+{
+    uint64_t cgen_var_31;
+    vkStream->read((uint64_t*)&cgen_var_31, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_31, (VkImage*)&forUnmarshaling->image, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pBinds, forUnmarshaling->bindCount * sizeof(const VkSparseMemoryBind));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
+    {
+        unmarshal_VkSparseMemoryBind(vkStream, (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
+    }
+}
+
+void marshal_VkImageSubresource(
+    VulkanStream* vkStream,
+    const VkImageSubresource* forMarshaling)
+{
+    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+    vkStream->write((uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->arrayLayer, sizeof(uint32_t));
+}
+
+void unmarshal_VkImageSubresource(
+    VulkanStream* vkStream,
+    VkImageSubresource* forUnmarshaling)
+{
+    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->mipLevel, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->arrayLayer, sizeof(uint32_t));
+}
+
+void marshal_VkOffset3D(
+    VulkanStream* vkStream,
+    const VkOffset3D* forMarshaling)
+{
+    vkStream->write((int32_t*)&forMarshaling->x, sizeof(int32_t));
+    vkStream->write((int32_t*)&forMarshaling->y, sizeof(int32_t));
+    vkStream->write((int32_t*)&forMarshaling->z, sizeof(int32_t));
+}
+
+void unmarshal_VkOffset3D(
+    VulkanStream* vkStream,
+    VkOffset3D* forUnmarshaling)
+{
+    vkStream->read((int32_t*)&forUnmarshaling->x, sizeof(int32_t));
+    vkStream->read((int32_t*)&forUnmarshaling->y, sizeof(int32_t));
+    vkStream->read((int32_t*)&forUnmarshaling->z, sizeof(int32_t));
+}
+
+void marshal_VkSparseImageMemoryBind(
+    VulkanStream* vkStream,
+    const VkSparseImageMemoryBind* forMarshaling)
+{
+    marshal_VkImageSubresource(vkStream, (VkImageSubresource*)(&forMarshaling->subresource));
+    marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->offset));
+    marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+    uint64_t cgen_var_32;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_32, 1);
+    vkStream->write((uint64_t*)&cgen_var_32, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
+    vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+}
+
+void unmarshal_VkSparseImageMemoryBind(
+    VulkanStream* vkStream,
+    VkSparseImageMemoryBind* forUnmarshaling)
+{
+    unmarshal_VkImageSubresource(vkStream, (VkImageSubresource*)(&forUnmarshaling->subresource));
+    unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->offset));
+    unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+    uint64_t cgen_var_33;
+    vkStream->read((uint64_t*)&cgen_var_33, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_33, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
+    vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+}
+
+void marshal_VkSparseImageMemoryBindInfo(
+    VulkanStream* vkStream,
+    const VkSparseImageMemoryBindInfo* forMarshaling)
+{
+    uint64_t cgen_var_34;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_34, 1);
+    vkStream->write((uint64_t*)&cgen_var_34, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
+    {
+        marshal_VkSparseImageMemoryBind(vkStream, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i));
+    }
+}
+
+void unmarshal_VkSparseImageMemoryBindInfo(
+    VulkanStream* vkStream,
+    VkSparseImageMemoryBindInfo* forUnmarshaling)
+{
+    uint64_t cgen_var_35;
+    vkStream->read((uint64_t*)&cgen_var_35, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_35, (VkImage*)&forUnmarshaling->image, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pBinds, forUnmarshaling->bindCount * sizeof(const VkSparseImageMemoryBind));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
+    {
+        unmarshal_VkSparseImageMemoryBind(vkStream, (VkSparseImageMemoryBind*)(forUnmarshaling->pBinds + i));
+    }
+}
+
+void marshal_VkBindSparseInfo(
+    VulkanStream* vkStream,
+    const VkBindSparseInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
+    if (forMarshaling->waitSemaphoreCount)
+    {
+        uint64_t* cgen_var_36;
+        vkStream->alloc((void**)&cgen_var_36, forMarshaling->waitSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_36, forMarshaling->waitSemaphoreCount);
+        vkStream->write((uint64_t*)cgen_var_36, forMarshaling->waitSemaphoreCount * 8);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->bufferBindCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i)
+    {
+        marshal_VkSparseBufferMemoryBindInfo(vkStream, (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->imageOpaqueBindCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageOpaqueBindCount; ++i)
+    {
+        marshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->imageBindCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageBindCount; ++i)
+    {
+        marshal_VkSparseImageMemoryBindInfo(vkStream, (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
+    if (forMarshaling->signalSemaphoreCount)
+    {
+        uint64_t* cgen_var_37;
+        vkStream->alloc((void**)&cgen_var_37, forMarshaling->signalSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSignalSemaphores, cgen_var_37, forMarshaling->signalSemaphoreCount);
+        vkStream->write((uint64_t*)cgen_var_37, forMarshaling->signalSemaphoreCount * 8);
+    }
+}
+
+void unmarshal_VkBindSparseInfo(
+    VulkanStream* vkStream,
+    VkBindSparseInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount * sizeof(const VkSemaphore));
+    if (forUnmarshaling->waitSemaphoreCount)
+    {
+        uint64_t* cgen_var_38;
+        vkStream->alloc((void**)&cgen_var_38, forUnmarshaling->waitSemaphoreCount * 8);
+        vkStream->read((uint64_t*)cgen_var_38, forUnmarshaling->waitSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_38, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->bufferBindCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pBufferBinds, forUnmarshaling->bufferBindCount * sizeof(const VkSparseBufferMemoryBindInfo));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferBindCount; ++i)
+    {
+        unmarshal_VkSparseBufferMemoryBindInfo(vkStream, (VkSparseBufferMemoryBindInfo*)(forUnmarshaling->pBufferBinds + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->imageOpaqueBindCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pImageOpaqueBinds, forUnmarshaling->imageOpaqueBindCount * sizeof(const VkSparseImageOpaqueMemoryBindInfo));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageOpaqueBindCount; ++i)
+    {
+        unmarshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, (VkSparseImageOpaqueMemoryBindInfo*)(forUnmarshaling->pImageOpaqueBinds + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->imageBindCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pImageBinds, forUnmarshaling->imageBindCount * sizeof(const VkSparseImageMemoryBindInfo));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageBindCount; ++i)
+    {
+        unmarshal_VkSparseImageMemoryBindInfo(vkStream, (VkSparseImageMemoryBindInfo*)(forUnmarshaling->pImageBinds + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount * sizeof(const VkSemaphore));
+    if (forUnmarshaling->signalSemaphoreCount)
+    {
+        uint64_t* cgen_var_39;
+        vkStream->alloc((void**)&cgen_var_39, forUnmarshaling->signalSemaphoreCount * 8);
+        vkStream->read((uint64_t*)cgen_var_39, forUnmarshaling->signalSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_39, (VkSemaphore*)forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount);
+    }
+}
+
+void marshal_VkFenceCreateInfo(
+    VulkanStream* vkStream,
+    const VkFenceCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkFenceCreateFlags*)&forMarshaling->flags, sizeof(VkFenceCreateFlags));
+}
+
+void unmarshal_VkFenceCreateInfo(
+    VulkanStream* vkStream,
+    VkFenceCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkFenceCreateFlags*)&forUnmarshaling->flags, sizeof(VkFenceCreateFlags));
+}
+
+void marshal_VkSemaphoreCreateInfo(
+    VulkanStream* vkStream,
+    const VkSemaphoreCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkSemaphoreCreateFlags*)&forMarshaling->flags, sizeof(VkSemaphoreCreateFlags));
+}
+
+void unmarshal_VkSemaphoreCreateInfo(
+    VulkanStream* vkStream,
+    VkSemaphoreCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkSemaphoreCreateFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreCreateFlags));
+}
+
+void marshal_VkEventCreateInfo(
+    VulkanStream* vkStream,
+    const VkEventCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkEventCreateFlags*)&forMarshaling->flags, sizeof(VkEventCreateFlags));
+}
+
+void unmarshal_VkEventCreateInfo(
+    VulkanStream* vkStream,
+    VkEventCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkEventCreateFlags*)&forUnmarshaling->flags, sizeof(VkEventCreateFlags));
+}
+
+void marshal_VkQueryPoolCreateInfo(
+    VulkanStream* vkStream,
+    const VkQueryPoolCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkQueryPoolCreateFlags*)&forMarshaling->flags, sizeof(VkQueryPoolCreateFlags));
+    vkStream->write((VkQueryType*)&forMarshaling->queryType, sizeof(VkQueryType));
+    vkStream->write((uint32_t*)&forMarshaling->queryCount, sizeof(uint32_t));
+    vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+}
+
+void unmarshal_VkQueryPoolCreateInfo(
+    VulkanStream* vkStream,
+    VkQueryPoolCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkQueryPoolCreateFlags*)&forUnmarshaling->flags, sizeof(VkQueryPoolCreateFlags));
+    vkStream->read((VkQueryType*)&forUnmarshaling->queryType, sizeof(VkQueryType));
+    vkStream->read((uint32_t*)&forUnmarshaling->queryCount, sizeof(uint32_t));
+    vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+}
+
+void marshal_VkBufferCreateInfo(
+    VulkanStream* vkStream,
+    const VkBufferCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+    vkStream->write((VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
+    vkStream->write((VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
+    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_40 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+    vkStream->putBe64(cgen_var_40);
+    if (forMarshaling->pQueueFamilyIndices)
+    {
+        vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+    }
+}
+
+void unmarshal_VkBufferCreateInfo(
+    VulkanStream* vkStream,
+    VkBufferCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferCreateFlags));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+    vkStream->read((VkBufferUsageFlags*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags));
+    vkStream->read((VkSharingMode*)&forUnmarshaling->sharingMode, sizeof(VkSharingMode));
+    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pQueueFamilyIndices)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+        vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+    }
+}
+
+void marshal_VkBufferViewCreateInfo(
+    VulkanStream* vkStream,
+    const VkBufferViewCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBufferViewCreateFlags*)&forMarshaling->flags, sizeof(VkBufferViewCreateFlags));
+    uint64_t cgen_var_42;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_42, 1);
+    vkStream->write((uint64_t*)&cgen_var_42, 1 * 8);
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBufferViewCreateInfo(
+    VulkanStream* vkStream,
+    VkBufferViewCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBufferViewCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferViewCreateFlags));
+    uint64_t cgen_var_43;
+    vkStream->read((uint64_t*)&cgen_var_43, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_43, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
+}
+
+void marshal_VkImageCreateInfo(
+    VulkanStream* vkStream,
+    const VkImageCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
+    vkStream->write((VkImageType*)&forMarshaling->imageType, sizeof(VkImageType));
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+    vkStream->write((uint32_t*)&forMarshaling->mipLevels, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->arrayLayers, sizeof(uint32_t));
+    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
+    vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
+    vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
+    vkStream->write((VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
+    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_44 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+    vkStream->putBe64(cgen_var_44);
+    if (forMarshaling->pQueueFamilyIndices)
+    {
+        vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+    }
+    vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkImageCreateInfo(
+    VulkanStream* vkStream,
+    VkImageCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkImageCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageCreateFlags));
+    vkStream->read((VkImageType*)&forUnmarshaling->imageType, sizeof(VkImageType));
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+    vkStream->read((uint32_t*)&forUnmarshaling->mipLevels, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->arrayLayers, sizeof(uint32_t));
+    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+    vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
+    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
+    vkStream->read((VkSharingMode*)&forUnmarshaling->sharingMode, sizeof(VkSharingMode));
+    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pQueueFamilyIndices)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+        vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+    }
+    vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
+}
+
+void marshal_VkSubresourceLayout(
+    VulkanStream* vkStream,
+    const VkSubresourceLayout* forMarshaling)
+{
+    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->rowPitch, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->arrayPitch, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->depthPitch, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkSubresourceLayout(
+    VulkanStream* vkStream,
+    VkSubresourceLayout* forUnmarshaling)
+{
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->rowPitch, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->arrayPitch, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->depthPitch, sizeof(VkDeviceSize));
+}
+
+void marshal_VkComponentMapping(
+    VulkanStream* vkStream,
+    const VkComponentMapping* forMarshaling)
+{
+    vkStream->write((VkComponentSwizzle*)&forMarshaling->r, sizeof(VkComponentSwizzle));
+    vkStream->write((VkComponentSwizzle*)&forMarshaling->g, sizeof(VkComponentSwizzle));
+    vkStream->write((VkComponentSwizzle*)&forMarshaling->b, sizeof(VkComponentSwizzle));
+    vkStream->write((VkComponentSwizzle*)&forMarshaling->a, sizeof(VkComponentSwizzle));
+}
+
+void unmarshal_VkComponentMapping(
+    VulkanStream* vkStream,
+    VkComponentMapping* forUnmarshaling)
+{
+    vkStream->read((VkComponentSwizzle*)&forUnmarshaling->r, sizeof(VkComponentSwizzle));
+    vkStream->read((VkComponentSwizzle*)&forUnmarshaling->g, sizeof(VkComponentSwizzle));
+    vkStream->read((VkComponentSwizzle*)&forUnmarshaling->b, sizeof(VkComponentSwizzle));
+    vkStream->read((VkComponentSwizzle*)&forUnmarshaling->a, sizeof(VkComponentSwizzle));
+}
+
+void marshal_VkImageSubresourceRange(
+    VulkanStream* vkStream,
+    const VkImageSubresourceRange* forMarshaling)
+{
+    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+    vkStream->write((uint32_t*)&forMarshaling->baseMipLevel, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->levelCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkImageSubresourceRange(
+    VulkanStream* vkStream,
+    VkImageSubresourceRange* forUnmarshaling)
+{
+    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->baseMipLevel, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->levelCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
+}
+
+void marshal_VkImageViewCreateInfo(
+    VulkanStream* vkStream,
+    const VkImageViewCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkImageViewCreateFlags*)&forMarshaling->flags, sizeof(VkImageViewCreateFlags));
+    uint64_t cgen_var_46;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_46, 1);
+    vkStream->write((uint64_t*)&cgen_var_46, 1 * 8);
+    vkStream->write((VkImageViewType*)&forMarshaling->viewType, sizeof(VkImageViewType));
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    marshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forMarshaling->components));
+    marshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+}
+
+void unmarshal_VkImageViewCreateInfo(
+    VulkanStream* vkStream,
+    VkImageViewCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkImageViewCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageViewCreateFlags));
+    uint64_t cgen_var_47;
+    vkStream->read((uint64_t*)&cgen_var_47, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_47, (VkImage*)&forUnmarshaling->image, 1);
+    vkStream->read((VkImageViewType*)&forUnmarshaling->viewType, sizeof(VkImageViewType));
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    unmarshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forUnmarshaling->components));
+    unmarshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+}
+
+void marshal_VkShaderModuleCreateInfo(
+    VulkanStream* vkStream,
+    const VkShaderModuleCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkShaderModuleCreateFlags*)&forMarshaling->flags, sizeof(VkShaderModuleCreateFlags));
+    uint64_t cgen_var_48 = (uint64_t)forMarshaling->codeSize;
+    vkStream->putBe64(cgen_var_48);
+    vkStream->write((const uint32_t*)forMarshaling->pCode, (forMarshaling->codeSize / 4) * sizeof(const uint32_t));
+}
+
+void unmarshal_VkShaderModuleCreateInfo(
+    VulkanStream* vkStream,
+    VkShaderModuleCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkShaderModuleCreateFlags*)&forUnmarshaling->flags, sizeof(VkShaderModuleCreateFlags));
+    forUnmarshaling->codeSize = (size_t)vkStream->getBe64();
+    vkStream->alloc((void**)&forUnmarshaling->pCode, (forUnmarshaling->codeSize / 4) * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pCode, (forUnmarshaling->codeSize / 4) * sizeof(const uint32_t));
+}
+
+void marshal_VkPipelineCacheCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineCacheCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineCacheCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
+    uint64_t cgen_var_50 = (uint64_t)forMarshaling->initialDataSize;
+    vkStream->putBe64(cgen_var_50);
+    vkStream->write((const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkPipelineCacheCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineCacheCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineCacheCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
+    forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
+    vkStream->alloc((void**)&forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
+    vkStream->read((void*)forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
+}
+
+void marshal_VkSpecializationMapEntry(
+    VulkanStream* vkStream,
+    const VkSpecializationMapEntry* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->constantID, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
+    uint64_t cgen_var_52 = (uint64_t)forMarshaling->size;
+    vkStream->putBe64(cgen_var_52);
+}
+
+void unmarshal_VkSpecializationMapEntry(
+    VulkanStream* vkStream,
+    VkSpecializationMapEntry* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->constantID, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
+    forUnmarshaling->size = (size_t)vkStream->getBe64();
+}
+
+void marshal_VkSpecializationInfo(
+    VulkanStream* vkStream,
+    const VkSpecializationInfo* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->mapEntryCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->mapEntryCount; ++i)
+    {
+        marshal_VkSpecializationMapEntry(vkStream, (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i));
+    }
+    uint64_t cgen_var_54 = (uint64_t)forMarshaling->dataSize;
+    vkStream->putBe64(cgen_var_54);
+    vkStream->write((const void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkSpecializationInfo(
+    VulkanStream* vkStream,
+    VkSpecializationInfo* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->mapEntryCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pMapEntries, forUnmarshaling->mapEntryCount * sizeof(const VkSpecializationMapEntry));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->mapEntryCount; ++i)
+    {
+        unmarshal_VkSpecializationMapEntry(vkStream, (VkSpecializationMapEntry*)(forUnmarshaling->pMapEntries + i));
+    }
+    forUnmarshaling->dataSize = (size_t)vkStream->getBe64();
+    vkStream->alloc((void**)&forUnmarshaling->pData, forUnmarshaling->dataSize * sizeof(const uint8_t));
+    vkStream->read((void*)forUnmarshaling->pData, forUnmarshaling->dataSize * sizeof(const uint8_t));
+}
+
+void marshal_VkPipelineShaderStageCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineShaderStageCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineShaderStageCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineShaderStageCreateFlags));
+    vkStream->write((VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
+    uint64_t cgen_var_56;
+    vkStream->handleMapping()->mapHandles_VkShaderModule_u64(&forMarshaling->module, &cgen_var_56, 1);
+    vkStream->write((uint64_t*)&cgen_var_56, 1 * 8);
+    vkStream->putString(forMarshaling->pName);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_57 = (uint64_t)(uintptr_t)forMarshaling->pSpecializationInfo;
+    vkStream->putBe64(cgen_var_57);
+    if (forMarshaling->pSpecializationInfo)
+    {
+        marshal_VkSpecializationInfo(vkStream, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo));
+    }
+}
+
+void unmarshal_VkPipelineShaderStageCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineShaderStageCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineShaderStageCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineShaderStageCreateFlags));
+    vkStream->read((VkShaderStageFlagBits*)&forUnmarshaling->stage, sizeof(VkShaderStageFlagBits));
+    uint64_t cgen_var_58;
+    vkStream->read((uint64_t*)&cgen_var_58, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_58, (VkShaderModule*)&forUnmarshaling->module, 1);
+    vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
+    // WARNING PTR CHECK
+    forUnmarshaling->pSpecializationInfo = (const VkSpecializationInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pSpecializationInfo)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pSpecializationInfo, sizeof(const VkSpecializationInfo));
+        unmarshal_VkSpecializationInfo(vkStream, (VkSpecializationInfo*)(forUnmarshaling->pSpecializationInfo));
+    }
+}
+
+void marshal_VkVertexInputBindingDescription(
+    VulkanStream* vkStream,
+    const VkVertexInputBindingDescription* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->stride, sizeof(uint32_t));
+    vkStream->write((VkVertexInputRate*)&forMarshaling->inputRate, sizeof(VkVertexInputRate));
+}
+
+void unmarshal_VkVertexInputBindingDescription(
+    VulkanStream* vkStream,
+    VkVertexInputBindingDescription* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->stride, sizeof(uint32_t));
+    vkStream->read((VkVertexInputRate*)&forUnmarshaling->inputRate, sizeof(VkVertexInputRate));
+}
+
+void marshal_VkVertexInputAttributeDescription(
+    VulkanStream* vkStream,
+    const VkVertexInputAttributeDescription* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->location, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
+}
+
+void unmarshal_VkVertexInputAttributeDescription(
+    VulkanStream* vkStream,
+    VkVertexInputAttributeDescription* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->location, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineVertexInputStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineVertexInputStateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineVertexInputStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineVertexInputStateCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDescriptionCount; ++i)
+    {
+        marshal_VkVertexInputBindingDescription(vkStream, (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexAttributeDescriptionCount; ++i)
+    {
+        marshal_VkVertexInputAttributeDescription(vkStream, (const VkVertexInputAttributeDescription*)(forMarshaling->pVertexAttributeDescriptions + i));
+    }
+}
+
+void unmarshal_VkPipelineVertexInputStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineVertexInputStateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineVertexInputStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineVertexInputStateCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pVertexBindingDescriptions, forUnmarshaling->vertexBindingDescriptionCount * sizeof(const VkVertexInputBindingDescription));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDescriptionCount; ++i)
+    {
+        unmarshal_VkVertexInputBindingDescription(vkStream, (VkVertexInputBindingDescription*)(forUnmarshaling->pVertexBindingDescriptions + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pVertexAttributeDescriptions, forUnmarshaling->vertexAttributeDescriptionCount * sizeof(const VkVertexInputAttributeDescription));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexAttributeDescriptionCount; ++i)
+    {
+        unmarshal_VkVertexInputAttributeDescription(vkStream, (VkVertexInputAttributeDescription*)(forUnmarshaling->pVertexAttributeDescriptions + i));
+    }
+}
+
+void marshal_VkPipelineInputAssemblyStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineInputAssemblyStateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineInputAssemblyStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineInputAssemblyStateCreateFlags));
+    vkStream->write((VkPrimitiveTopology*)&forMarshaling->topology, sizeof(VkPrimitiveTopology));
+    vkStream->write((VkBool32*)&forMarshaling->primitiveRestartEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkPipelineInputAssemblyStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineInputAssemblyStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineInputAssemblyStateCreateFlags));
+    vkStream->read((VkPrimitiveTopology*)&forUnmarshaling->topology, sizeof(VkPrimitiveTopology));
+    vkStream->read((VkBool32*)&forUnmarshaling->primitiveRestartEnable, sizeof(VkBool32));
+}
+
+void marshal_VkPipelineTessellationStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineTessellationStateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineTessellationStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineTessellationStateCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->patchControlPoints, sizeof(uint32_t));
+}
+
+void unmarshal_VkPipelineTessellationStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineTessellationStateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineTessellationStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineTessellationStateCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->patchControlPoints, sizeof(uint32_t));
+}
+
+void marshal_VkViewport(
+    VulkanStream* vkStream,
+    const VkViewport* forMarshaling)
+{
+    vkStream->write((float*)&forMarshaling->x, sizeof(float));
+    vkStream->write((float*)&forMarshaling->y, sizeof(float));
+    vkStream->write((float*)&forMarshaling->width, sizeof(float));
+    vkStream->write((float*)&forMarshaling->height, sizeof(float));
+    vkStream->write((float*)&forMarshaling->minDepth, sizeof(float));
+    vkStream->write((float*)&forMarshaling->maxDepth, sizeof(float));
+}
+
+void unmarshal_VkViewport(
+    VulkanStream* vkStream,
+    VkViewport* forUnmarshaling)
+{
+    vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->width, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->height, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->minDepth, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->maxDepth, sizeof(float));
+}
+
+void marshal_VkOffset2D(
+    VulkanStream* vkStream,
+    const VkOffset2D* forMarshaling)
+{
+    vkStream->write((int32_t*)&forMarshaling->x, sizeof(int32_t));
+    vkStream->write((int32_t*)&forMarshaling->y, sizeof(int32_t));
+}
+
+void unmarshal_VkOffset2D(
+    VulkanStream* vkStream,
+    VkOffset2D* forUnmarshaling)
+{
+    vkStream->read((int32_t*)&forUnmarshaling->x, sizeof(int32_t));
+    vkStream->read((int32_t*)&forUnmarshaling->y, sizeof(int32_t));
+}
+
+void marshal_VkExtent2D(
+    VulkanStream* vkStream,
+    const VkExtent2D* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
+}
+
+void unmarshal_VkExtent2D(
+    VulkanStream* vkStream,
+    VkExtent2D* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
+}
+
+void marshal_VkRect2D(
+    VulkanStream* vkStream,
+    const VkRect2D* forMarshaling)
+{
+    marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->offset));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->extent));
+}
+
+void unmarshal_VkRect2D(
+    VulkanStream* vkStream,
+    VkRect2D* forUnmarshaling)
+{
+    unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->offset));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->extent));
+}
+
+void marshal_VkPipelineViewportStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineViewportStateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineViewportStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineViewportStateCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_60 = (uint64_t)(uintptr_t)forMarshaling->pViewports;
+    vkStream->putBe64(cgen_var_60);
+    if (forMarshaling->pViewports)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
+        {
+            marshal_VkViewport(vkStream, (const VkViewport*)(forMarshaling->pViewports + i));
+        }
+    }
+    vkStream->write((uint32_t*)&forMarshaling->scissorCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_61 = (uint64_t)(uintptr_t)forMarshaling->pScissors;
+    vkStream->putBe64(cgen_var_61);
+    if (forMarshaling->pScissors)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i)
+        {
+            marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pScissors + i));
+        }
+    }
+}
+
+void unmarshal_VkPipelineViewportStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineViewportStateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineViewportStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineViewportStateCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pViewports = (const VkViewport*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pViewports)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pViewports, forUnmarshaling->viewportCount * sizeof(const VkViewport));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
+        {
+            unmarshal_VkViewport(vkStream, (VkViewport*)(forUnmarshaling->pViewports + i));
+        }
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->scissorCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pScissors = (const VkRect2D*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pScissors)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pScissors, forUnmarshaling->scissorCount * sizeof(const VkRect2D));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->scissorCount; ++i)
+        {
+            unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pScissors + i));
+        }
+    }
+}
+
+void marshal_VkPipelineRasterizationStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineRasterizationStateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineRasterizationStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineRasterizationStateCreateFlags));
+    vkStream->write((VkBool32*)&forMarshaling->depthClampEnable, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
+    vkStream->write((VkPolygonMode*)&forMarshaling->polygonMode, sizeof(VkPolygonMode));
+    vkStream->write((VkCullModeFlags*)&forMarshaling->cullMode, sizeof(VkCullModeFlags));
+    vkStream->write((VkFrontFace*)&forMarshaling->frontFace, sizeof(VkFrontFace));
+    vkStream->write((VkBool32*)&forMarshaling->depthBiasEnable, sizeof(VkBool32));
+    vkStream->write((float*)&forMarshaling->depthBiasConstantFactor, sizeof(float));
+    vkStream->write((float*)&forMarshaling->depthBiasClamp, sizeof(float));
+    vkStream->write((float*)&forMarshaling->depthBiasSlopeFactor, sizeof(float));
+    vkStream->write((float*)&forMarshaling->lineWidth, sizeof(float));
+}
+
+void unmarshal_VkPipelineRasterizationStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineRasterizationStateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineRasterizationStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineRasterizationStateCreateFlags));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthClampEnable, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
+    vkStream->read((VkPolygonMode*)&forUnmarshaling->polygonMode, sizeof(VkPolygonMode));
+    vkStream->read((VkCullModeFlags*)&forUnmarshaling->cullMode, sizeof(VkCullModeFlags));
+    vkStream->read((VkFrontFace*)&forUnmarshaling->frontFace, sizeof(VkFrontFace));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthBiasEnable, sizeof(VkBool32));
+    vkStream->read((float*)&forUnmarshaling->depthBiasConstantFactor, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->depthBiasClamp, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->depthBiasSlopeFactor, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->lineWidth, sizeof(float));
+}
+
+void marshal_VkPipelineMultisampleStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineMultisampleStateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineMultisampleStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineMultisampleStateCreateFlags));
+    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+    vkStream->write((VkBool32*)&forMarshaling->sampleShadingEnable, sizeof(VkBool32));
+    vkStream->write((float*)&forMarshaling->minSampleShading, sizeof(float));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_64 = (uint64_t)(uintptr_t)forMarshaling->pSampleMask;
+    vkStream->putBe64(cgen_var_64);
+    if (forMarshaling->pSampleMask)
+    {
+        vkStream->write((const VkSampleMask*)forMarshaling->pSampleMask, (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+    }
+    vkStream->write((VkBool32*)&forMarshaling->alphaToCoverageEnable, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->alphaToOneEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkPipelineMultisampleStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineMultisampleStateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineMultisampleStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineMultisampleStateCreateFlags));
+    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+    vkStream->read((VkBool32*)&forUnmarshaling->sampleShadingEnable, sizeof(VkBool32));
+    vkStream->read((float*)&forUnmarshaling->minSampleShading, sizeof(float));
+    // WARNING PTR CHECK
+    forUnmarshaling->pSampleMask = (const VkSampleMask*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pSampleMask)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pSampleMask, (((forUnmarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+        vkStream->read((VkSampleMask*)forUnmarshaling->pSampleMask, (((forUnmarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->alphaToCoverageEnable, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->alphaToOneEnable, sizeof(VkBool32));
+}
+
+void marshal_VkStencilOpState(
+    VulkanStream* vkStream,
+    const VkStencilOpState* forMarshaling)
+{
+    vkStream->write((VkStencilOp*)&forMarshaling->failOp, sizeof(VkStencilOp));
+    vkStream->write((VkStencilOp*)&forMarshaling->passOp, sizeof(VkStencilOp));
+    vkStream->write((VkStencilOp*)&forMarshaling->depthFailOp, sizeof(VkStencilOp));
+    vkStream->write((VkCompareOp*)&forMarshaling->compareOp, sizeof(VkCompareOp));
+    vkStream->write((uint32_t*)&forMarshaling->compareMask, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->writeMask, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->reference, sizeof(uint32_t));
+}
+
+void unmarshal_VkStencilOpState(
+    VulkanStream* vkStream,
+    VkStencilOpState* forUnmarshaling)
+{
+    vkStream->read((VkStencilOp*)&forUnmarshaling->failOp, sizeof(VkStencilOp));
+    vkStream->read((VkStencilOp*)&forUnmarshaling->passOp, sizeof(VkStencilOp));
+    vkStream->read((VkStencilOp*)&forUnmarshaling->depthFailOp, sizeof(VkStencilOp));
+    vkStream->read((VkCompareOp*)&forUnmarshaling->compareOp, sizeof(VkCompareOp));
+    vkStream->read((uint32_t*)&forUnmarshaling->compareMask, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->writeMask, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->reference, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineDepthStencilStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineDepthStencilStateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineDepthStencilStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineDepthStencilStateCreateFlags));
+    vkStream->write((VkBool32*)&forMarshaling->depthTestEnable, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->depthWriteEnable, sizeof(VkBool32));
+    vkStream->write((VkCompareOp*)&forMarshaling->depthCompareOp, sizeof(VkCompareOp));
+    vkStream->write((VkBool32*)&forMarshaling->depthBoundsTestEnable, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->stencilTestEnable, sizeof(VkBool32));
+    marshal_VkStencilOpState(vkStream, (VkStencilOpState*)(&forMarshaling->front));
+    marshal_VkStencilOpState(vkStream, (VkStencilOpState*)(&forMarshaling->back));
+    vkStream->write((float*)&forMarshaling->minDepthBounds, sizeof(float));
+    vkStream->write((float*)&forMarshaling->maxDepthBounds, sizeof(float));
+}
+
+void unmarshal_VkPipelineDepthStencilStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineDepthStencilStateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineDepthStencilStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineDepthStencilStateCreateFlags));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthTestEnable, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthWriteEnable, sizeof(VkBool32));
+    vkStream->read((VkCompareOp*)&forUnmarshaling->depthCompareOp, sizeof(VkCompareOp));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthBoundsTestEnable, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->stencilTestEnable, sizeof(VkBool32));
+    unmarshal_VkStencilOpState(vkStream, (VkStencilOpState*)(&forUnmarshaling->front));
+    unmarshal_VkStencilOpState(vkStream, (VkStencilOpState*)(&forUnmarshaling->back));
+    vkStream->read((float*)&forUnmarshaling->minDepthBounds, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->maxDepthBounds, sizeof(float));
+}
+
+void marshal_VkPipelineColorBlendAttachmentState(
+    VulkanStream* vkStream,
+    const VkPipelineColorBlendAttachmentState* forMarshaling)
+{
+    vkStream->write((VkBool32*)&forMarshaling->blendEnable, sizeof(VkBool32));
+    vkStream->write((VkBlendFactor*)&forMarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
+    vkStream->write((VkBlendFactor*)&forMarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
+    vkStream->write((VkBlendOp*)&forMarshaling->colorBlendOp, sizeof(VkBlendOp));
+    vkStream->write((VkBlendFactor*)&forMarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
+    vkStream->write((VkBlendFactor*)&forMarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
+    vkStream->write((VkBlendOp*)&forMarshaling->alphaBlendOp, sizeof(VkBlendOp));
+    vkStream->write((VkColorComponentFlags*)&forMarshaling->colorWriteMask, sizeof(VkColorComponentFlags));
+}
+
+void unmarshal_VkPipelineColorBlendAttachmentState(
+    VulkanStream* vkStream,
+    VkPipelineColorBlendAttachmentState* forUnmarshaling)
+{
+    vkStream->read((VkBool32*)&forUnmarshaling->blendEnable, sizeof(VkBool32));
+    vkStream->read((VkBlendFactor*)&forUnmarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
+    vkStream->read((VkBlendFactor*)&forUnmarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
+    vkStream->read((VkBlendOp*)&forUnmarshaling->colorBlendOp, sizeof(VkBlendOp));
+    vkStream->read((VkBlendFactor*)&forUnmarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
+    vkStream->read((VkBlendFactor*)&forUnmarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
+    vkStream->read((VkBlendOp*)&forUnmarshaling->alphaBlendOp, sizeof(VkBlendOp));
+    vkStream->read((VkColorComponentFlags*)&forUnmarshaling->colorWriteMask, sizeof(VkColorComponentFlags));
+}
+
+void marshal_VkPipelineColorBlendStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineColorBlendStateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineColorBlendStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineColorBlendStateCreateFlags));
+    vkStream->write((VkBool32*)&forMarshaling->logicOpEnable, sizeof(VkBool32));
+    vkStream->write((VkLogicOp*)&forMarshaling->logicOp, sizeof(VkLogicOp));
+    vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
+    {
+        marshal_VkPipelineColorBlendAttachmentState(vkStream, (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i));
+    }
+    vkStream->write((float*)forMarshaling->blendConstants, 4 * sizeof(float));
+}
+
+void unmarshal_VkPipelineColorBlendStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineColorBlendStateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineColorBlendStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineColorBlendStateCreateFlags));
+    vkStream->read((VkBool32*)&forUnmarshaling->logicOpEnable, sizeof(VkBool32));
+    vkStream->read((VkLogicOp*)&forUnmarshaling->logicOp, sizeof(VkLogicOp));
+    vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount * sizeof(const VkPipelineColorBlendAttachmentState));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
+    {
+        unmarshal_VkPipelineColorBlendAttachmentState(vkStream, (VkPipelineColorBlendAttachmentState*)(forUnmarshaling->pAttachments + i));
+    }
+    vkStream->read((float*)forUnmarshaling->blendConstants, 4 * sizeof(float));
+}
+
+void marshal_VkPipelineDynamicStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineDynamicStateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineDynamicStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineDynamicStateCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->dynamicStateCount, sizeof(uint32_t));
+    vkStream->write((const VkDynamicState*)forMarshaling->pDynamicStates, forMarshaling->dynamicStateCount * sizeof(const VkDynamicState));
+}
+
+void unmarshal_VkPipelineDynamicStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineDynamicStateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineDynamicStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineDynamicStateCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->dynamicStateCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDynamicStates, forUnmarshaling->dynamicStateCount * sizeof(const VkDynamicState));
+    vkStream->read((VkDynamicState*)forUnmarshaling->pDynamicStates, forUnmarshaling->dynamicStateCount * sizeof(const VkDynamicState));
+}
+
+void marshal_VkGraphicsPipelineCreateInfo(
+    VulkanStream* vkStream,
+    const VkGraphicsPipelineCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i)
+    {
+        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_66 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
+    vkStream->putBe64(cgen_var_66);
+    if (forMarshaling->pTessellationState)
+    {
+        marshal_VkPipelineTessellationStateCreateInfo(vkStream, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_67 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
+    vkStream->putBe64(cgen_var_67);
+    if (forMarshaling->pViewportState)
+    {
+        marshal_VkPipelineViewportStateCreateInfo(vkStream, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
+    }
+    marshal_VkPipelineRasterizationStateCreateInfo(vkStream, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_68 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
+    vkStream->putBe64(cgen_var_68);
+    if (forMarshaling->pMultisampleState)
+    {
+        marshal_VkPipelineMultisampleStateCreateInfo(vkStream, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_69 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
+    vkStream->putBe64(cgen_var_69);
+    if (forMarshaling->pDepthStencilState)
+    {
+        marshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_70 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
+    vkStream->putBe64(cgen_var_70);
+    if (forMarshaling->pColorBlendState)
+    {
+        marshal_VkPipelineColorBlendStateCreateInfo(vkStream, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_71 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
+    vkStream->putBe64(cgen_var_71);
+    if (forMarshaling->pDynamicState)
+    {
+        marshal_VkPipelineDynamicStateCreateInfo(vkStream, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
+    }
+    uint64_t cgen_var_72;
+    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_72, 1);
+    vkStream->write((uint64_t*)&cgen_var_72, 1 * 8);
+    uint64_t cgen_var_73;
+    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_73, 1);
+    vkStream->write((uint64_t*)&cgen_var_73, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
+    uint64_t cgen_var_74;
+    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_74, 1);
+    vkStream->write((uint64_t*)&cgen_var_74, 1 * 8);
+    vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
+}
+
+void unmarshal_VkGraphicsPipelineCreateInfo(
+    VulkanStream* vkStream,
+    VkGraphicsPipelineCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pStages, forUnmarshaling->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i)
+    {
+        unmarshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pVertexInputState, sizeof(const VkPipelineVertexInputStateCreateInfo));
+    unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
+    vkStream->alloc((void**)&forUnmarshaling->pInputAssemblyState, sizeof(const VkPipelineInputAssemblyStateCreateInfo));
+    unmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
+    // WARNING PTR CHECK
+    forUnmarshaling->pTessellationState = (const VkPipelineTessellationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pTessellationState)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pTessellationState, sizeof(const VkPipelineTessellationStateCreateInfo));
+        unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pViewportState = (const VkPipelineViewportStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pViewportState)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pViewportState, sizeof(const VkPipelineViewportStateCreateInfo));
+        unmarshal_VkPipelineViewportStateCreateInfo(vkStream, (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pRasterizationState, sizeof(const VkPipelineRasterizationStateCreateInfo));
+    unmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
+    // WARNING PTR CHECK
+    forUnmarshaling->pMultisampleState = (const VkPipelineMultisampleStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pMultisampleState)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pMultisampleState, sizeof(const VkPipelineMultisampleStateCreateInfo));
+        unmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pDepthStencilState = (const VkPipelineDepthStencilStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pDepthStencilState)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pDepthStencilState, sizeof(const VkPipelineDepthStencilStateCreateInfo));
+        unmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pColorBlendState = (const VkPipelineColorBlendStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pColorBlendState)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pColorBlendState, sizeof(const VkPipelineColorBlendStateCreateInfo));
+        unmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pDynamicState = (const VkPipelineDynamicStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pDynamicState)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pDynamicState, sizeof(const VkPipelineDynamicStateCreateInfo));
+        unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
+    }
+    uint64_t cgen_var_81;
+    vkStream->read((uint64_t*)&cgen_var_81, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_81, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+    uint64_t cgen_var_82;
+    vkStream->read((uint64_t*)&cgen_var_82, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_82, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
+    uint64_t cgen_var_83;
+    vkStream->read((uint64_t*)&cgen_var_83, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_83, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+    vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
+}
+
+void marshal_VkComputePipelineCreateInfo(
+    VulkanStream* vkStream,
+    const VkComputePipelineCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
+    marshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage));
+    uint64_t cgen_var_84;
+    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_84, 1);
+    vkStream->write((uint64_t*)&cgen_var_84, 1 * 8);
+    uint64_t cgen_var_85;
+    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_85, 1);
+    vkStream->write((uint64_t*)&cgen_var_85, 1 * 8);
+    vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
+}
+
+void unmarshal_VkComputePipelineCreateInfo(
+    VulkanStream* vkStream,
+    VkComputePipelineCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
+    unmarshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forUnmarshaling->stage));
+    uint64_t cgen_var_86;
+    vkStream->read((uint64_t*)&cgen_var_86, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_86, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+    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);
+    vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
+}
+
+void marshal_VkPushConstantRange(
+    VulkanStream* vkStream,
+    const VkPushConstantRange* forMarshaling)
+{
+    vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+    vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
+}
+
+void unmarshal_VkPushConstantRange(
+    VulkanStream* vkStream,
+    VkPushConstantRange* forUnmarshaling)
+{
+    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineLayoutCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineLayoutCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineLayoutCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineLayoutCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
+    if (forMarshaling->setLayoutCount)
+    {
+        uint64_t* cgen_var_88;
+        vkStream->alloc((void**)&cgen_var_88, forMarshaling->setLayoutCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_88, forMarshaling->setLayoutCount);
+        vkStream->write((uint64_t*)cgen_var_88, forMarshaling->setLayoutCount * 8);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i)
+    {
+        marshal_VkPushConstantRange(vkStream, (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i));
+    }
+}
+
+void unmarshal_VkPipelineLayoutCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineLayoutCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineLayoutCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineLayoutCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSetLayouts, forUnmarshaling->setLayoutCount * sizeof(const VkDescriptorSetLayout));
+    if (forUnmarshaling->setLayoutCount)
+    {
+        uint64_t* cgen_var_89;
+        vkStream->alloc((void**)&cgen_var_89, forUnmarshaling->setLayoutCount * 8);
+        vkStream->read((uint64_t*)cgen_var_89, forUnmarshaling->setLayoutCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_89, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->setLayoutCount);
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->pushConstantRangeCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pPushConstantRanges, forUnmarshaling->pushConstantRangeCount * sizeof(const VkPushConstantRange));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i)
+    {
+        unmarshal_VkPushConstantRange(vkStream, (VkPushConstantRange*)(forUnmarshaling->pPushConstantRanges + i));
+    }
+}
+
+void marshal_VkSamplerCreateInfo(
+    VulkanStream* vkStream,
+    const VkSamplerCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkSamplerCreateFlags*)&forMarshaling->flags, sizeof(VkSamplerCreateFlags));
+    vkStream->write((VkFilter*)&forMarshaling->magFilter, sizeof(VkFilter));
+    vkStream->write((VkFilter*)&forMarshaling->minFilter, sizeof(VkFilter));
+    vkStream->write((VkSamplerMipmapMode*)&forMarshaling->mipmapMode, sizeof(VkSamplerMipmapMode));
+    vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeU, sizeof(VkSamplerAddressMode));
+    vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeV, sizeof(VkSamplerAddressMode));
+    vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeW, sizeof(VkSamplerAddressMode));
+    vkStream->write((float*)&forMarshaling->mipLodBias, sizeof(float));
+    vkStream->write((VkBool32*)&forMarshaling->anisotropyEnable, sizeof(VkBool32));
+    vkStream->write((float*)&forMarshaling->maxAnisotropy, sizeof(float));
+    vkStream->write((VkBool32*)&forMarshaling->compareEnable, sizeof(VkBool32));
+    vkStream->write((VkCompareOp*)&forMarshaling->compareOp, sizeof(VkCompareOp));
+    vkStream->write((float*)&forMarshaling->minLod, sizeof(float));
+    vkStream->write((float*)&forMarshaling->maxLod, sizeof(float));
+    vkStream->write((VkBorderColor*)&forMarshaling->borderColor, sizeof(VkBorderColor));
+    vkStream->write((VkBool32*)&forMarshaling->unnormalizedCoordinates, sizeof(VkBool32));
+}
+
+void unmarshal_VkSamplerCreateInfo(
+    VulkanStream* vkStream,
+    VkSamplerCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkSamplerCreateFlags*)&forUnmarshaling->flags, sizeof(VkSamplerCreateFlags));
+    vkStream->read((VkFilter*)&forUnmarshaling->magFilter, sizeof(VkFilter));
+    vkStream->read((VkFilter*)&forUnmarshaling->minFilter, sizeof(VkFilter));
+    vkStream->read((VkSamplerMipmapMode*)&forUnmarshaling->mipmapMode, sizeof(VkSamplerMipmapMode));
+    vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeU, sizeof(VkSamplerAddressMode));
+    vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeV, sizeof(VkSamplerAddressMode));
+    vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeW, sizeof(VkSamplerAddressMode));
+    vkStream->read((float*)&forUnmarshaling->mipLodBias, sizeof(float));
+    vkStream->read((VkBool32*)&forUnmarshaling->anisotropyEnable, sizeof(VkBool32));
+    vkStream->read((float*)&forUnmarshaling->maxAnisotropy, sizeof(float));
+    vkStream->read((VkBool32*)&forUnmarshaling->compareEnable, sizeof(VkBool32));
+    vkStream->read((VkCompareOp*)&forUnmarshaling->compareOp, sizeof(VkCompareOp));
+    vkStream->read((float*)&forUnmarshaling->minLod, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->maxLod, sizeof(float));
+    vkStream->read((VkBorderColor*)&forUnmarshaling->borderColor, sizeof(VkBorderColor));
+    vkStream->read((VkBool32*)&forUnmarshaling->unnormalizedCoordinates, sizeof(VkBool32));
+}
+
+void marshal_VkDescriptorSetLayoutBinding(
+    VulkanStream* vkStream,
+    const VkDescriptorSetLayoutBinding* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
+    vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
+    vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
+    vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_90 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
+    vkStream->putBe64(cgen_var_90);
+    if (forMarshaling->pImmutableSamplers)
+    {
+        if (forMarshaling->descriptorCount)
+        {
+            uint64_t* cgen_var_91;
+            vkStream->alloc((void**)&cgen_var_91, forMarshaling->descriptorCount * 8);
+            vkStream->handleMapping()->mapHandles_VkSampler_u64(forMarshaling->pImmutableSamplers, cgen_var_91, forMarshaling->descriptorCount);
+            vkStream->write((uint64_t*)cgen_var_91, forMarshaling->descriptorCount * 8);
+        }
+    }
+}
+
+void unmarshal_VkDescriptorSetLayoutBinding(
+    VulkanStream* vkStream,
+    VkDescriptorSetLayoutBinding* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
+    vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
+    vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
+    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
+    // WARNING PTR CHECK
+    forUnmarshaling->pImmutableSamplers = (const VkSampler*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pImmutableSamplers)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pImmutableSamplers, forUnmarshaling->descriptorCount * sizeof(const VkSampler));
+        if (forUnmarshaling->descriptorCount)
+        {
+            uint64_t* cgen_var_93;
+            vkStream->alloc((void**)&cgen_var_93, forUnmarshaling->descriptorCount * 8);
+            vkStream->read((uint64_t*)cgen_var_93, forUnmarshaling->descriptorCount * 8);
+            vkStream->handleMapping()->mapHandles_u64_VkSampler(cgen_var_93, (VkSampler*)forUnmarshaling->pImmutableSamplers, forUnmarshaling->descriptorCount);
+        }
+    }
+}
+
+void marshal_VkDescriptorSetLayoutCreateInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorSetLayoutCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDescriptorSetLayoutCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorSetLayoutCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindingCount; ++i)
+    {
+        marshal_VkDescriptorSetLayoutBinding(vkStream, (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i));
+    }
+}
+
+void unmarshal_VkDescriptorSetLayoutCreateInfo(
+    VulkanStream* vkStream,
+    VkDescriptorSetLayoutCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDescriptorSetLayoutCreateFlags*)&forUnmarshaling->flags, sizeof(VkDescriptorSetLayoutCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pBindings, forUnmarshaling->bindingCount * sizeof(const VkDescriptorSetLayoutBinding));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindingCount; ++i)
+    {
+        unmarshal_VkDescriptorSetLayoutBinding(vkStream, (VkDescriptorSetLayoutBinding*)(forUnmarshaling->pBindings + i));
+    }
+}
+
+void marshal_VkDescriptorPoolSize(
+    VulkanStream* vkStream,
+    const VkDescriptorPoolSize* forMarshaling)
+{
+    vkStream->write((VkDescriptorType*)&forMarshaling->type, sizeof(VkDescriptorType));
+    vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkDescriptorPoolSize(
+    VulkanStream* vkStream,
+    VkDescriptorPoolSize* forUnmarshaling)
+{
+    vkStream->read((VkDescriptorType*)&forUnmarshaling->type, sizeof(VkDescriptorType));
+    vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
+}
+
+void marshal_VkDescriptorPoolCreateInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorPoolCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDescriptorPoolCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorPoolCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->maxSets, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->poolSizeCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->poolSizeCount; ++i)
+    {
+        marshal_VkDescriptorPoolSize(vkStream, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i));
+    }
+}
+
+void unmarshal_VkDescriptorPoolCreateInfo(
+    VulkanStream* vkStream,
+    VkDescriptorPoolCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDescriptorPoolCreateFlags*)&forUnmarshaling->flags, sizeof(VkDescriptorPoolCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxSets, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->poolSizeCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pPoolSizes, forUnmarshaling->poolSizeCount * sizeof(const VkDescriptorPoolSize));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->poolSizeCount; ++i)
+    {
+        unmarshal_VkDescriptorPoolSize(vkStream, (VkDescriptorPoolSize*)(forUnmarshaling->pPoolSizes + i));
+    }
+}
+
+void marshal_VkDescriptorSetAllocateInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorSetAllocateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_94;
+    vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool, &cgen_var_94, 1);
+    vkStream->write((uint64_t*)&cgen_var_94, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
+    if (forMarshaling->descriptorSetCount)
+    {
+        uint64_t* cgen_var_95;
+        vkStream->alloc((void**)&cgen_var_95, forMarshaling->descriptorSetCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_95, forMarshaling->descriptorSetCount);
+        vkStream->write((uint64_t*)cgen_var_95, forMarshaling->descriptorSetCount * 8);
+    }
+}
+
+void unmarshal_VkDescriptorSetAllocateInfo(
+    VulkanStream* vkStream,
+    VkDescriptorSetAllocateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_96;
+    vkStream->read((uint64_t*)&cgen_var_96, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_96, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSetLayouts, forUnmarshaling->descriptorSetCount * sizeof(const VkDescriptorSetLayout));
+    if (forUnmarshaling->descriptorSetCount)
+    {
+        uint64_t* cgen_var_97;
+        vkStream->alloc((void**)&cgen_var_97, forUnmarshaling->descriptorSetCount * 8);
+        vkStream->read((uint64_t*)cgen_var_97, forUnmarshaling->descriptorSetCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_97, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->descriptorSetCount);
+    }
+}
+
+void marshal_VkDescriptorImageInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorImageInfo* forMarshaling)
+{
+    uint64_t cgen_var_98;
+    vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_98, 1);
+    vkStream->write((uint64_t*)&cgen_var_98, 1 * 8);
+    uint64_t cgen_var_99;
+    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_99, 1);
+    vkStream->write((uint64_t*)&cgen_var_99, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkDescriptorImageInfo(
+    VulkanStream* vkStream,
+    VkDescriptorImageInfo* forUnmarshaling)
+{
+    uint64_t cgen_var_100;
+    vkStream->read((uint64_t*)&cgen_var_100, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_100, (VkSampler*)&forUnmarshaling->sampler, 1);
+    uint64_t cgen_var_101;
+    vkStream->read((uint64_t*)&cgen_var_101, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_101, (VkImageView*)&forUnmarshaling->imageView, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
+}
+
+void marshal_VkDescriptorBufferInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorBufferInfo* forMarshaling)
+{
+    uint64_t cgen_var_102;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_102, 1);
+    vkStream->write((uint64_t*)&cgen_var_102, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkDescriptorBufferInfo(
+    VulkanStream* vkStream,
+    VkDescriptorBufferInfo* forUnmarshaling)
+{
+    uint64_t cgen_var_103;
+    vkStream->read((uint64_t*)&cgen_var_103, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_103, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
+}
+
+void marshal_VkWriteDescriptorSet(
+    VulkanStream* vkStream,
+    const VkWriteDescriptorSet* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_104;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_104, 1);
+    vkStream->write((uint64_t*)&cgen_var_104, 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_105 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
+    vkStream->putBe64(cgen_var_105);
+    if (forMarshaling->pImageInfo)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
+        {
+            marshal_VkDescriptorImageInfo(vkStream, (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_106 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
+    vkStream->putBe64(cgen_var_106);
+    if (forMarshaling->pBufferInfo)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
+        {
+            marshal_VkDescriptorBufferInfo(vkStream, (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_107 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
+    vkStream->putBe64(cgen_var_107);
+    if (forMarshaling->pTexelBufferView)
+    {
+        if (forMarshaling->descriptorCount)
+        {
+            uint64_t* cgen_var_108;
+            vkStream->alloc((void**)&cgen_var_108, forMarshaling->descriptorCount * 8);
+            vkStream->handleMapping()->mapHandles_VkBufferView_u64(forMarshaling->pTexelBufferView, cgen_var_108, forMarshaling->descriptorCount);
+            vkStream->write((uint64_t*)cgen_var_108, forMarshaling->descriptorCount * 8);
+        }
+    }
+}
+
+void unmarshal_VkWriteDescriptorSet(
+    VulkanStream* vkStream,
+    VkWriteDescriptorSet* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_109;
+    vkStream->read((uint64_t*)&cgen_var_109, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_109, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
+    vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
+    // WARNING PTR CHECK
+    forUnmarshaling->pImageInfo = (const VkDescriptorImageInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pImageInfo)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pImageInfo, forUnmarshaling->descriptorCount * sizeof(const VkDescriptorImageInfo));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
+        {
+            unmarshal_VkDescriptorImageInfo(vkStream, (VkDescriptorImageInfo*)(forUnmarshaling->pImageInfo + i));
+        }
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pBufferInfo = (const VkDescriptorBufferInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pBufferInfo)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pBufferInfo, forUnmarshaling->descriptorCount * sizeof(const VkDescriptorBufferInfo));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
+        {
+            unmarshal_VkDescriptorBufferInfo(vkStream, (VkDescriptorBufferInfo*)(forUnmarshaling->pBufferInfo + i));
+        }
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pTexelBufferView = (const VkBufferView*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pTexelBufferView)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pTexelBufferView, forUnmarshaling->descriptorCount * sizeof(const VkBufferView));
+        if (forUnmarshaling->descriptorCount)
+        {
+            uint64_t* cgen_var_113;
+            vkStream->alloc((void**)&cgen_var_113, forUnmarshaling->descriptorCount * 8);
+            vkStream->read((uint64_t*)cgen_var_113, forUnmarshaling->descriptorCount * 8);
+            vkStream->handleMapping()->mapHandles_u64_VkBufferView(cgen_var_113, (VkBufferView*)forUnmarshaling->pTexelBufferView, forUnmarshaling->descriptorCount);
+        }
+    }
+}
+
+void marshal_VkCopyDescriptorSet(
+    VulkanStream* vkStream,
+    const VkCopyDescriptorSet* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_114;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_114, 1);
+    vkStream->write((uint64_t*)&cgen_var_114, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->srcBinding, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->srcArrayElement, sizeof(uint32_t));
+    uint64_t cgen_var_115;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_115, 1);
+    vkStream->write((uint64_t*)&cgen_var_115, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkCopyDescriptorSet(
+    VulkanStream* vkStream,
+    VkCopyDescriptorSet* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_116;
+    vkStream->read((uint64_t*)&cgen_var_116, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_116, (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_117;
+    vkStream->read((uint64_t*)&cgen_var_117, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_117, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
+}
+
+void marshal_VkFramebufferCreateInfo(
+    VulkanStream* vkStream,
+    const VkFramebufferCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkFramebufferCreateFlags*)&forMarshaling->flags, sizeof(VkFramebufferCreateFlags));
+    uint64_t cgen_var_118;
+    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_118, 1);
+    vkStream->write((uint64_t*)&cgen_var_118, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
+    if (forMarshaling->attachmentCount)
+    {
+        uint64_t* cgen_var_119;
+        vkStream->alloc((void**)&cgen_var_119, forMarshaling->attachmentCount * 8);
+        vkStream->handleMapping()->mapHandles_VkImageView_u64(forMarshaling->pAttachments, cgen_var_119, forMarshaling->attachmentCount);
+        vkStream->write((uint64_t*)cgen_var_119, forMarshaling->attachmentCount * 8);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->layers, sizeof(uint32_t));
+}
+
+void unmarshal_VkFramebufferCreateInfo(
+    VulkanStream* vkStream,
+    VkFramebufferCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkFramebufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkFramebufferCreateFlags));
+    uint64_t cgen_var_120;
+    vkStream->read((uint64_t*)&cgen_var_120, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_120, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount * sizeof(const VkImageView));
+    if (forUnmarshaling->attachmentCount)
+    {
+        uint64_t* cgen_var_121;
+        vkStream->alloc((void**)&cgen_var_121, forUnmarshaling->attachmentCount * 8);
+        vkStream->read((uint64_t*)cgen_var_121, forUnmarshaling->attachmentCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkImageView(cgen_var_121, (VkImageView*)forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount);
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->layers, sizeof(uint32_t));
+}
+
+void marshal_VkAttachmentDescription(
+    VulkanStream* vkStream,
+    const VkAttachmentDescription* forMarshaling)
+{
+    vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
+    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
+    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
+    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
+    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+    vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
+    vkStream->write((VkImageLayout*)&forMarshaling->finalLayout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkAttachmentDescription(
+    VulkanStream* vkStream,
+    VkAttachmentDescription* forUnmarshaling)
+{
+    vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
+    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
+    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
+    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->finalLayout, sizeof(VkImageLayout));
+}
+
+void marshal_VkAttachmentReference(
+    VulkanStream* vkStream,
+    const VkAttachmentReference* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
+    vkStream->write((VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkAttachmentReference(
+    VulkanStream* vkStream,
+    VkAttachmentReference* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->attachment, sizeof(uint32_t));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->layout, sizeof(VkImageLayout));
+}
+
+void marshal_VkSubpassDescription(
+    VulkanStream* vkStream,
+    const VkSubpassDescription* forMarshaling)
+{
+    vkStream->write((VkSubpassDescriptionFlags*)&forMarshaling->flags, sizeof(VkSubpassDescriptionFlags));
+    vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    vkStream->write((uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
+    {
+        marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
+    {
+        marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_122 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
+    vkStream->putBe64(cgen_var_122);
+    if (forMarshaling->pResolveAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
+        {
+            marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_123 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
+    vkStream->putBe64(cgen_var_123);
+    if (forMarshaling->pDepthStencilAttachment)
+    {
+        marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pPreserveAttachments, forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkSubpassDescription(
+    VulkanStream* vkStream,
+    VkSubpassDescription* forUnmarshaling)
+{
+    vkStream->read((VkSubpassDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkSubpassDescriptionFlags));
+    vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pInputAttachments, forUnmarshaling->inputAttachmentCount * sizeof(const VkAttachmentReference));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i)
+    {
+        unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pInputAttachments + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pColorAttachments, forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
+    {
+        unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pColorAttachments + i));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pResolveAttachments = (const VkAttachmentReference*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pResolveAttachments)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pResolveAttachments, forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
+        {
+            unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pResolveAttachments + i));
+        }
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pDepthStencilAttachment = (const VkAttachmentReference*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pDepthStencilAttachment)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pDepthStencilAttachment, sizeof(const VkAttachmentReference));
+        unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pDepthStencilAttachment));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->preserveAttachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pPreserveAttachments, forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pPreserveAttachments, forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+}
+
+void marshal_VkSubpassDependency(
+    VulkanStream* vkStream,
+    const VkSubpassDependency* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
+    vkStream->write((VkPipelineStageFlags*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
+    vkStream->write((VkPipelineStageFlags*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+    vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
+    vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
+    vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+}
+
+void unmarshal_VkSubpassDependency(
+    VulkanStream* vkStream,
+    VkSubpassDependency* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->srcSubpass, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dstSubpass, sizeof(uint32_t));
+    vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
+    vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+    vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
+    vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
+    vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+}
+
+void marshal_VkRenderPassCreateInfo(
+    VulkanStream* vkStream,
+    const VkRenderPassCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkRenderPassCreateFlags*)&forMarshaling->flags, sizeof(VkRenderPassCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
+    {
+        marshal_VkAttachmentDescription(vkStream, (const VkAttachmentDescription*)(forMarshaling->pAttachments + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i)
+    {
+        marshal_VkSubpassDescription(vkStream, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i)
+    {
+        marshal_VkSubpassDependency(vkStream, (const VkSubpassDependency*)(forMarshaling->pDependencies + i));
+    }
+}
+
+void unmarshal_VkRenderPassCreateInfo(
+    VulkanStream* vkStream,
+    VkRenderPassCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags, sizeof(VkRenderPassCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount * sizeof(const VkAttachmentDescription));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
+    {
+        unmarshal_VkAttachmentDescription(vkStream, (VkAttachmentDescription*)(forUnmarshaling->pAttachments + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSubpasses, forUnmarshaling->subpassCount * sizeof(const VkSubpassDescription));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i)
+    {
+        unmarshal_VkSubpassDescription(vkStream, (VkSubpassDescription*)(forUnmarshaling->pSubpasses + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDependencies, forUnmarshaling->dependencyCount * sizeof(const VkSubpassDependency));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i)
+    {
+        unmarshal_VkSubpassDependency(vkStream, (VkSubpassDependency*)(forUnmarshaling->pDependencies + i));
+    }
+}
+
+void marshal_VkCommandPoolCreateInfo(
+    VulkanStream* vkStream,
+    const VkCommandPoolCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkCommandPoolCreateFlags*)&forMarshaling->flags, sizeof(VkCommandPoolCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkCommandPoolCreateInfo(
+    VulkanStream* vkStream,
+    VkCommandPoolCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkCommandPoolCreateFlags*)&forUnmarshaling->flags, sizeof(VkCommandPoolCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
+}
+
+void marshal_VkCommandBufferAllocateInfo(
+    VulkanStream* vkStream,
+    const VkCommandBufferAllocateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_126;
+    vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool, &cgen_var_126, 1);
+    vkStream->write((uint64_t*)&cgen_var_126, 1 * 8);
+    vkStream->write((VkCommandBufferLevel*)&forMarshaling->level, sizeof(VkCommandBufferLevel));
+    vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkCommandBufferAllocateInfo(
+    VulkanStream* vkStream,
+    VkCommandBufferAllocateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_127;
+    vkStream->read((uint64_t*)&cgen_var_127, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_127, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
+    vkStream->read((VkCommandBufferLevel*)&forUnmarshaling->level, sizeof(VkCommandBufferLevel));
+    vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
+}
+
+void marshal_VkCommandBufferInheritanceInfo(
+    VulkanStream* vkStream,
+    const VkCommandBufferInheritanceInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_128;
+    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_128, 1);
+    vkStream->write((uint64_t*)&cgen_var_128, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
+    uint64_t cgen_var_129;
+    vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_129, 1);
+    vkStream->write((uint64_t*)&cgen_var_129, 1 * 8);
+    vkStream->write((VkBool32*)&forMarshaling->occlusionQueryEnable, sizeof(VkBool32));
+    vkStream->write((VkQueryControlFlags*)&forMarshaling->queryFlags, sizeof(VkQueryControlFlags));
+    vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+}
+
+void unmarshal_VkCommandBufferInheritanceInfo(
+    VulkanStream* vkStream,
+    VkCommandBufferInheritanceInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_130;
+    vkStream->read((uint64_t*)&cgen_var_130, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_130, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
+    uint64_t cgen_var_131;
+    vkStream->read((uint64_t*)&cgen_var_131, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_131, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+    vkStream->read((VkBool32*)&forUnmarshaling->occlusionQueryEnable, sizeof(VkBool32));
+    vkStream->read((VkQueryControlFlags*)&forUnmarshaling->queryFlags, sizeof(VkQueryControlFlags));
+    vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+}
+
+void marshal_VkCommandBufferBeginInfo(
+    VulkanStream* vkStream,
+    const VkCommandBufferBeginInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkCommandBufferUsageFlags*)&forMarshaling->flags, sizeof(VkCommandBufferUsageFlags));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_132 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
+    vkStream->putBe64(cgen_var_132);
+    if (forMarshaling->pInheritanceInfo)
+    {
+        marshal_VkCommandBufferInheritanceInfo(vkStream, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo));
+    }
+}
+
+void unmarshal_VkCommandBufferBeginInfo(
+    VulkanStream* vkStream,
+    VkCommandBufferBeginInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkCommandBufferUsageFlags*)&forUnmarshaling->flags, sizeof(VkCommandBufferUsageFlags));
+    // WARNING PTR CHECK
+    forUnmarshaling->pInheritanceInfo = (const VkCommandBufferInheritanceInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pInheritanceInfo)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pInheritanceInfo, sizeof(const VkCommandBufferInheritanceInfo));
+        unmarshal_VkCommandBufferInheritanceInfo(vkStream, (VkCommandBufferInheritanceInfo*)(forUnmarshaling->pInheritanceInfo));
+    }
+}
+
+void marshal_VkBufferCopy(
+    VulkanStream* vkStream,
+    const VkBufferCopy* forMarshaling)
+{
+    vkStream->write((VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBufferCopy(
+    VulkanStream* vkStream,
+    VkBufferCopy* forUnmarshaling)
+{
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->srcOffset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstOffset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkImageSubresourceLayers(
+    VulkanStream* vkStream,
+    const VkImageSubresourceLayers* forMarshaling)
+{
+    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+    vkStream->write((uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkImageSubresourceLayers(
+    VulkanStream* vkStream,
+    VkImageSubresourceLayers* forUnmarshaling)
+{
+    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->mipLevel, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
+}
+
+void marshal_VkImageCopy(
+    VulkanStream* vkStream,
+    const VkImageCopy* forMarshaling)
+{
+    marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+    marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->srcOffset));
+    marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+    marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->dstOffset));
+    marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+}
+
+void unmarshal_VkImageCopy(
+    VulkanStream* vkStream,
+    VkImageCopy* forUnmarshaling)
+{
+    unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+    unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->srcOffset));
+    unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+    unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->dstOffset));
+    unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+}
+
+void marshal_VkImageBlit(
+    VulkanStream* vkStream,
+    const VkImageBlit* forMarshaling)
+{
+    marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i)
+    {
+        marshal_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->srcOffsets + i));
+    }
+    marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i)
+    {
+        marshal_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->dstOffsets + i));
+    }
+}
+
+void unmarshal_VkImageBlit(
+    VulkanStream* vkStream,
+    VkImageBlit* forUnmarshaling)
+{
+    unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i)
+    {
+        unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
+    }
+    unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i)
+    {
+        unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
+    }
+}
+
+void marshal_VkBufferImageCopy(
+    VulkanStream* vkStream,
+    const VkBufferImageCopy* forMarshaling)
+{
+    vkStream->write((VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
+    vkStream->write((uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
+    marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
+    marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->imageOffset));
+    marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->imageExtent));
+}
+
+void unmarshal_VkBufferImageCopy(
+    VulkanStream* vkStream,
+    VkBufferImageCopy* forUnmarshaling)
+{
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->bufferOffset, sizeof(VkDeviceSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->bufferRowLength, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->bufferImageHeight, sizeof(uint32_t));
+    unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
+    unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->imageOffset));
+    unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->imageExtent));
+}
+
+void marshal_VkClearColorValue(
+    VulkanStream* vkStream,
+    const VkClearColorValue* forMarshaling)
+{
+    vkStream->write((float*)forMarshaling->float32, 4 * sizeof(float));
+}
+
+void unmarshal_VkClearColorValue(
+    VulkanStream* vkStream,
+    VkClearColorValue* forUnmarshaling)
+{
+    vkStream->read((float*)forUnmarshaling->float32, 4 * sizeof(float));
+}
+
+void marshal_VkClearDepthStencilValue(
+    VulkanStream* vkStream,
+    const VkClearDepthStencilValue* forMarshaling)
+{
+    vkStream->write((float*)&forMarshaling->depth, sizeof(float));
+    vkStream->write((uint32_t*)&forMarshaling->stencil, sizeof(uint32_t));
+}
+
+void unmarshal_VkClearDepthStencilValue(
+    VulkanStream* vkStream,
+    VkClearDepthStencilValue* forUnmarshaling)
+{
+    vkStream->read((float*)&forUnmarshaling->depth, sizeof(float));
+    vkStream->read((uint32_t*)&forUnmarshaling->stencil, sizeof(uint32_t));
+}
+
+void marshal_VkClearValue(
+    VulkanStream* vkStream,
+    const VkClearValue* forMarshaling)
+{
+    marshal_VkClearColorValue(vkStream, (VkClearColorValue*)(&forMarshaling->color));
+}
+
+void unmarshal_VkClearValue(
+    VulkanStream* vkStream,
+    VkClearValue* forUnmarshaling)
+{
+    unmarshal_VkClearColorValue(vkStream, (VkClearColorValue*)(&forUnmarshaling->color));
+}
+
+void marshal_VkClearAttachment(
+    VulkanStream* vkStream,
+    const VkClearAttachment* forMarshaling)
+{
+    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+    vkStream->write((uint32_t*)&forMarshaling->colorAttachment, sizeof(uint32_t));
+    marshal_VkClearValue(vkStream, (VkClearValue*)(&forMarshaling->clearValue));
+}
+
+void unmarshal_VkClearAttachment(
+    VulkanStream* vkStream,
+    VkClearAttachment* forUnmarshaling)
+{
+    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachment, sizeof(uint32_t));
+    unmarshal_VkClearValue(vkStream, (VkClearValue*)(&forUnmarshaling->clearValue));
+}
+
+void marshal_VkClearRect(
+    VulkanStream* vkStream,
+    const VkClearRect* forMarshaling)
+{
+    marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->rect));
+    vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkClearRect(
+    VulkanStream* vkStream,
+    VkClearRect* forUnmarshaling)
+{
+    unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->rect));
+    vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
+}
+
+void marshal_VkImageResolve(
+    VulkanStream* vkStream,
+    const VkImageResolve* forMarshaling)
+{
+    marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+    marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->srcOffset));
+    marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+    marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->dstOffset));
+    marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+}
+
+void unmarshal_VkImageResolve(
+    VulkanStream* vkStream,
+    VkImageResolve* forUnmarshaling)
+{
+    unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+    unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->srcOffset));
+    unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+    unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->dstOffset));
+    unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+}
+
+void marshal_VkMemoryBarrier(
+    VulkanStream* vkStream,
+    const VkMemoryBarrier* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
+    vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
+}
+
+void unmarshal_VkMemoryBarrier(
+    VulkanStream* vkStream,
+    VkMemoryBarrier* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
+    vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
+}
+
+void marshal_VkBufferMemoryBarrier(
+    VulkanStream* vkStream,
+    const VkBufferMemoryBarrier* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
+    vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
+    vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+    uint64_t cgen_var_134;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_134, 1);
+    vkStream->write((uint64_t*)&cgen_var_134, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBufferMemoryBarrier(
+    VulkanStream* vkStream,
+    VkBufferMemoryBarrier* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
+    vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+    uint64_t cgen_var_135;
+    vkStream->read((uint64_t*)&cgen_var_135, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_135, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkImageMemoryBarrier(
+    VulkanStream* vkStream,
+    const VkImageMemoryBarrier* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
+    vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
+    vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
+    vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
+    vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+    uint64_t cgen_var_136;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_136, 1);
+    vkStream->write((uint64_t*)&cgen_var_136, 1 * 8);
+    marshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+}
+
+void unmarshal_VkImageMemoryBarrier(
+    VulkanStream* vkStream,
+    VkImageMemoryBarrier* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
+    vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
+    vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+    uint64_t cgen_var_137;
+    vkStream->read((uint64_t*)&cgen_var_137, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_137, (VkImage*)&forUnmarshaling->image, 1);
+    unmarshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+}
+
+void marshal_VkRenderPassBeginInfo(
+    VulkanStream* vkStream,
+    const VkRenderPassBeginInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_138;
+    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_138, 1);
+    vkStream->write((uint64_t*)&cgen_var_138, 1 * 8);
+    uint64_t cgen_var_139;
+    vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_139, 1);
+    vkStream->write((uint64_t*)&cgen_var_139, 1 * 8);
+    marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->renderArea));
+    vkStream->write((uint32_t*)&forMarshaling->clearValueCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_140 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
+    vkStream->putBe64(cgen_var_140);
+    if (forMarshaling->pClearValues)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i)
+        {
+            marshal_VkClearValue(vkStream, (const VkClearValue*)(forMarshaling->pClearValues + i));
+        }
+    }
+}
+
+void unmarshal_VkRenderPassBeginInfo(
+    VulkanStream* vkStream,
+    VkRenderPassBeginInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_141;
+    vkStream->read((uint64_t*)&cgen_var_141, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_141, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+    uint64_t cgen_var_142;
+    vkStream->read((uint64_t*)&cgen_var_142, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_142, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+    unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->renderArea));
+    vkStream->read((uint32_t*)&forUnmarshaling->clearValueCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pClearValues = (const VkClearValue*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pClearValues)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pClearValues, forUnmarshaling->clearValueCount * sizeof(const VkClearValue));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->clearValueCount; ++i)
+        {
+            unmarshal_VkClearValue(vkStream, (VkClearValue*)(forUnmarshaling->pClearValues + i));
+        }
+    }
+}
+
+void marshal_VkDispatchIndirectCommand(
+    VulkanStream* vkStream,
+    const VkDispatchIndirectCommand* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->x, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->y, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->z, sizeof(uint32_t));
+}
+
+void unmarshal_VkDispatchIndirectCommand(
+    VulkanStream* vkStream,
+    VkDispatchIndirectCommand* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->x, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->y, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->z, sizeof(uint32_t));
+}
+
+void marshal_VkDrawIndexedIndirectCommand(
+    VulkanStream* vkStream,
+    const VkDrawIndexedIndirectCommand* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->indexCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->firstIndex, sizeof(uint32_t));
+    vkStream->write((int32_t*)&forMarshaling->vertexOffset, sizeof(int32_t));
+    vkStream->write((uint32_t*)&forMarshaling->firstInstance, sizeof(uint32_t));
+}
+
+void unmarshal_VkDrawIndexedIndirectCommand(
+    VulkanStream* vkStream,
+    VkDrawIndexedIndirectCommand* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->indexCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->instanceCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->firstIndex, sizeof(uint32_t));
+    vkStream->read((int32_t*)&forUnmarshaling->vertexOffset, sizeof(int32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->firstInstance, sizeof(uint32_t));
+}
+
+void marshal_VkDrawIndirectCommand(
+    VulkanStream* vkStream,
+    const VkDrawIndirectCommand* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->vertexCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->firstVertex, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->firstInstance, sizeof(uint32_t));
+}
+
+void unmarshal_VkDrawIndirectCommand(
+    VulkanStream* vkStream,
+    VkDrawIndirectCommand* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->vertexCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->instanceCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->firstVertex, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->firstInstance, sizeof(uint32_t));
+}
+
+void marshal_VkBaseOutStructure(
+    VulkanStream* vkStream,
+    const VkBaseOutStructure* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((VkBaseOutStructure*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+}
+
+void unmarshal_VkBaseOutStructure(
+    VulkanStream* vkStream,
+    VkBaseOutStructure* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((VkBaseOutStructure*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+}
+
+void marshal_VkBaseInStructure(
+    VulkanStream* vkStream,
+    const VkBaseInStructure* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const VkBaseInStructure*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+}
+
+void unmarshal_VkBaseInStructure(
+    VulkanStream* vkStream,
+    VkBaseInStructure* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((VkBaseInStructure*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+}
+
+#endif
+#ifdef VK_VERSION_1_1
+void marshal_VkPhysicalDeviceSubgroupProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSubgroupProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
+    vkStream->write((VkShaderStageFlags*)&forMarshaling->supportedStages, sizeof(VkShaderStageFlags));
+    vkStream->write((VkSubgroupFeatureFlags*)&forMarshaling->supportedOperations, sizeof(VkSubgroupFeatureFlags));
+    vkStream->write((VkBool32*)&forMarshaling->quadOperationsInAllStages, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSubgroupProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSubgroupProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->subgroupSize, sizeof(uint32_t));
+    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->supportedStages, sizeof(VkShaderStageFlags));
+    vkStream->read((VkSubgroupFeatureFlags*)&forUnmarshaling->supportedOperations, sizeof(VkSubgroupFeatureFlags));
+    vkStream->read((VkBool32*)&forUnmarshaling->quadOperationsInAllStages, sizeof(VkBool32));
+}
+
+void marshal_VkBindBufferMemoryInfo(
+    VulkanStream* vkStream,
+    const VkBindBufferMemoryInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_144;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_144, 1);
+    vkStream->write((uint64_t*)&cgen_var_144, 1 * 8);
+    uint64_t cgen_var_145;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_145, 1);
+    vkStream->write((uint64_t*)&cgen_var_145, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBindBufferMemoryInfo(
+    VulkanStream* vkStream,
+    VkBindBufferMemoryInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_146;
+    vkStream->read((uint64_t*)&cgen_var_146, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_146, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_147;
+    vkStream->read((uint64_t*)&cgen_var_147, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_147, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
+}
+
+void marshal_VkBindImageMemoryInfo(
+    VulkanStream* vkStream,
+    const VkBindImageMemoryInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_148;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &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);
+    vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBindImageMemoryInfo(
+    VulkanStream* vkStream,
+    VkBindImageMemoryInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, 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_VkImage(&cgen_var_150, (VkImage*)&forUnmarshaling->image, 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);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
+}
+
+void marshal_VkPhysicalDevice16BitStorageFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDevice16BitStorageFeatures* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->storagePushConstant16, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->storageInputOutput16, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevice16BitStorageFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDevice16BitStorageFeatures* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant16, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->storageInputOutput16, sizeof(VkBool32));
+}
+
+void marshal_VkMemoryDedicatedRequirements(
+    VulkanStream* vkStream,
+    const VkMemoryDedicatedRequirements* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
+}
+
+void unmarshal_VkMemoryDedicatedRequirements(
+    VulkanStream* vkStream,
+    VkMemoryDedicatedRequirements* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
+}
+
+void marshal_VkMemoryDedicatedAllocateInfo(
+    VulkanStream* vkStream,
+    const VkMemoryDedicatedAllocateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        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_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_153, 1);
+    vkStream->write((uint64_t*)&cgen_var_153, 1 * 8);
+}
+
+void unmarshal_VkMemoryDedicatedAllocateInfo(
+    VulkanStream* vkStream,
+    VkMemoryDedicatedAllocateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, 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_VkBuffer(&cgen_var_155, (VkBuffer*)&forUnmarshaling->buffer, 1);
+}
+
+void marshal_VkMemoryAllocateFlagsInfo(
+    VulkanStream* vkStream,
+    const VkMemoryAllocateFlagsInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkMemoryAllocateFlags*)&forMarshaling->flags, sizeof(VkMemoryAllocateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryAllocateFlagsInfo(
+    VulkanStream* vkStream,
+    VkMemoryAllocateFlagsInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkMemoryAllocateFlags*)&forUnmarshaling->flags, sizeof(VkMemoryAllocateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void marshal_VkDeviceGroupRenderPassBeginInfo(
+    VulkanStream* vkStream,
+    const VkDeviceGroupRenderPassBeginInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->deviceRenderAreaCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->deviceRenderAreaCount; ++i)
+    {
+        marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i));
+    }
+}
+
+void unmarshal_VkDeviceGroupRenderPassBeginInfo(
+    VulkanStream* vkStream,
+    VkDeviceGroupRenderPassBeginInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceRenderAreaCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDeviceRenderAreas, forUnmarshaling->deviceRenderAreaCount * sizeof(const VkRect2D));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->deviceRenderAreaCount; ++i)
+    {
+        unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pDeviceRenderAreas + i));
+    }
+}
+
+void marshal_VkDeviceGroupCommandBufferBeginInfo(
+    VulkanStream* vkStream,
+    const VkDeviceGroupCommandBufferBeginInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void unmarshal_VkDeviceGroupCommandBufferBeginInfo(
+    VulkanStream* vkStream,
+    VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void marshal_VkDeviceGroupSubmitInfo(
+    VulkanStream* vkStream,
+    const VkDeviceGroupSubmitInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pWaitSemaphoreDeviceIndices, forMarshaling->waitSemaphoreCount * sizeof(const uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pCommandBufferDeviceMasks, forMarshaling->commandBufferCount * sizeof(const uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pSignalSemaphoreDeviceIndices, forMarshaling->signalSemaphoreCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkDeviceGroupSubmitInfo(
+    VulkanStream* vkStream,
+    VkDeviceGroupSubmitInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphoreDeviceIndices, forUnmarshaling->waitSemaphoreCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pWaitSemaphoreDeviceIndices, forUnmarshaling->waitSemaphoreCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pCommandBufferDeviceMasks, forUnmarshaling->commandBufferCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pCommandBufferDeviceMasks, forUnmarshaling->commandBufferCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphoreDeviceIndices, forUnmarshaling->signalSemaphoreCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pSignalSemaphoreDeviceIndices, forUnmarshaling->signalSemaphoreCount * sizeof(const uint32_t));
+}
+
+void marshal_VkDeviceGroupBindSparseInfo(
+    VulkanStream* vkStream,
+    const VkDeviceGroupBindSparseInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->resourceDeviceIndex, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->memoryDeviceIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkDeviceGroupBindSparseInfo(
+    VulkanStream* vkStream,
+    VkDeviceGroupBindSparseInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->resourceDeviceIndex, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryDeviceIndex, sizeof(uint32_t));
+}
+
+void marshal_VkBindBufferMemoryDeviceGroupInfo(
+    VulkanStream* vkStream,
+    const VkBindBufferMemoryDeviceGroupInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices, forMarshaling->deviceIndexCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkBindBufferMemoryDeviceGroupInfo(
+    VulkanStream* vkStream,
+    VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+}
+
+void marshal_VkBindImageMemoryDeviceGroupInfo(
+    VulkanStream* vkStream,
+    const VkBindImageMemoryDeviceGroupInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices, forMarshaling->deviceIndexCount * sizeof(const uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->splitInstanceBindRegionCount; ++i)
+    {
+        marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i));
+    }
+}
+
+void unmarshal_VkBindImageMemoryDeviceGroupInfo(
+    VulkanStream* vkStream,
+    VkBindImageMemoryDeviceGroupInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSplitInstanceBindRegions, forUnmarshaling->splitInstanceBindRegionCount * sizeof(const VkRect2D));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->splitInstanceBindRegionCount; ++i)
+    {
+        unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pSplitInstanceBindRegions + i));
+    }
+}
+
+void marshal_VkPhysicalDeviceGroupProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceGroupProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
+    vkStream->write((VkPhysicalDevice*)forMarshaling->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
+    vkStream->write((VkBool32*)&forMarshaling->subsetAllocation, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceGroupProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceGroupProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
+    vkStream->read((VkPhysicalDevice*)forUnmarshaling->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
+    vkStream->read((VkBool32*)&forUnmarshaling->subsetAllocation, sizeof(VkBool32));
+}
+
+void marshal_VkDeviceGroupDeviceCreateInfo(
+    VulkanStream* vkStream,
+    const VkDeviceGroupDeviceCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
+    if (forMarshaling->physicalDeviceCount)
+    {
+        uint64_t* cgen_var_156;
+        vkStream->alloc((void**)&cgen_var_156, forMarshaling->physicalDeviceCount * 8);
+        vkStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(forMarshaling->pPhysicalDevices, cgen_var_156, forMarshaling->physicalDeviceCount);
+        vkStream->write((uint64_t*)cgen_var_156, forMarshaling->physicalDeviceCount * 8);
+    }
+}
+
+void unmarshal_VkDeviceGroupDeviceCreateInfo(
+    VulkanStream* vkStream,
+    VkDeviceGroupDeviceCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pPhysicalDevices, forUnmarshaling->physicalDeviceCount * sizeof(const VkPhysicalDevice));
+    if (forUnmarshaling->physicalDeviceCount)
+    {
+        uint64_t* cgen_var_157;
+        vkStream->alloc((void**)&cgen_var_157, forUnmarshaling->physicalDeviceCount * 8);
+        vkStream->read((uint64_t*)cgen_var_157, forUnmarshaling->physicalDeviceCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_157, (VkPhysicalDevice*)forUnmarshaling->pPhysicalDevices, forUnmarshaling->physicalDeviceCount);
+    }
+}
+
+void marshal_VkBufferMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    const VkBufferMemoryRequirementsInfo2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    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);
+}
+
+void unmarshal_VkBufferMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    VkBufferMemoryRequirementsInfo2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    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);
+}
+
+void marshal_VkImageMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    const VkImageMemoryRequirementsInfo2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_160;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_160, 1);
+    vkStream->write((uint64_t*)&cgen_var_160, 1 * 8);
+}
+
+void unmarshal_VkImageMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    VkImageMemoryRequirementsInfo2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_161;
+    vkStream->read((uint64_t*)&cgen_var_161, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_161, (VkImage*)&forUnmarshaling->image, 1);
+}
+
+void marshal_VkImageSparseMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    const VkImageSparseMemoryRequirementsInfo2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    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);
+}
+
+void unmarshal_VkImageSparseMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    VkImageSparseMemoryRequirementsInfo2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, 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_VkImage(&cgen_var_163, (VkImage*)&forUnmarshaling->image, 1);
+}
+
+void marshal_VkMemoryRequirements2(
+    VulkanStream* vkStream,
+    const VkMemoryRequirements2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkMemoryRequirements(vkStream, (VkMemoryRequirements*)(&forMarshaling->memoryRequirements));
+}
+
+void unmarshal_VkMemoryRequirements2(
+    VulkanStream* vkStream,
+    VkMemoryRequirements2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkMemoryRequirements(vkStream, (VkMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
+}
+
+void marshal_VkSparseImageMemoryRequirements2(
+    VulkanStream* vkStream,
+    const VkSparseImageMemoryRequirements2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkSparseImageMemoryRequirements(vkStream, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements));
+}
+
+void unmarshal_VkSparseImageMemoryRequirements2(
+    VulkanStream* vkStream,
+    VkSparseImageMemoryRequirements2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkSparseImageMemoryRequirements(vkStream, (VkSparseImageMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
+}
+
+void marshal_VkPhysicalDeviceFeatures2(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceFeatures2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(&forMarshaling->features));
+}
+
+void unmarshal_VkPhysicalDeviceFeatures2(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceFeatures2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(&forUnmarshaling->features));
+}
+
+void marshal_VkPhysicalDeviceProperties2(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceProperties2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkPhysicalDeviceProperties(vkStream, (VkPhysicalDeviceProperties*)(&forMarshaling->properties));
+}
+
+void unmarshal_VkPhysicalDeviceProperties2(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceProperties2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkPhysicalDeviceProperties(vkStream, (VkPhysicalDeviceProperties*)(&forUnmarshaling->properties));
+}
+
+void marshal_VkFormatProperties2(
+    VulkanStream* vkStream,
+    const VkFormatProperties2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkFormatProperties(vkStream, (VkFormatProperties*)(&forMarshaling->formatProperties));
+}
+
+void unmarshal_VkFormatProperties2(
+    VulkanStream* vkStream,
+    VkFormatProperties2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkFormatProperties(vkStream, (VkFormatProperties*)(&forUnmarshaling->formatProperties));
+}
+
+void marshal_VkImageFormatProperties2(
+    VulkanStream* vkStream,
+    const VkImageFormatProperties2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
+}
+
+void unmarshal_VkImageFormatProperties2(
+    VulkanStream* vkStream,
+    VkImageFormatProperties2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
+}
+
+void marshal_VkPhysicalDeviceImageFormatInfo2(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceImageFormatInfo2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    vkStream->write((VkImageType*)&forMarshaling->type, sizeof(VkImageType));
+    vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
+    vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
+    vkStream->write((VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
+}
+
+void unmarshal_VkPhysicalDeviceImageFormatInfo2(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceImageFormatInfo2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    vkStream->read((VkImageType*)&forUnmarshaling->type, sizeof(VkImageType));
+    vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
+    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
+    vkStream->read((VkImageCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageCreateFlags));
+}
+
+void marshal_VkQueueFamilyProperties2(
+    VulkanStream* vkStream,
+    const VkQueueFamilyProperties2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkQueueFamilyProperties(vkStream, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties));
+}
+
+void unmarshal_VkQueueFamilyProperties2(
+    VulkanStream* vkStream,
+    VkQueueFamilyProperties2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkQueueFamilyProperties(vkStream, (VkQueueFamilyProperties*)(&forUnmarshaling->queueFamilyProperties));
+}
+
+void marshal_VkPhysicalDeviceMemoryProperties2(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMemoryProperties2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkPhysicalDeviceMemoryProperties(vkStream, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties));
+}
+
+void unmarshal_VkPhysicalDeviceMemoryProperties2(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMemoryProperties2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkPhysicalDeviceMemoryProperties(vkStream, (VkPhysicalDeviceMemoryProperties*)(&forUnmarshaling->memoryProperties));
+}
+
+void marshal_VkSparseImageFormatProperties2(
+    VulkanStream* vkStream,
+    const VkSparseImageFormatProperties2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forMarshaling->properties));
+}
+
+void unmarshal_VkSparseImageFormatProperties2(
+    VulkanStream* vkStream,
+    VkSparseImageFormatProperties2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forUnmarshaling->properties));
+}
+
+void marshal_VkPhysicalDeviceSparseImageFormatInfo2(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    vkStream->write((VkImageType*)&forMarshaling->type, sizeof(VkImageType));
+    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
+    vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
+    vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
+}
+
+void unmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    vkStream->read((VkImageType*)&forUnmarshaling->type, sizeof(VkImageType));
+    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
+    vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
+}
+
+void marshal_VkPhysicalDevicePointClippingProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDevicePointClippingProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
+}
+
+void unmarshal_VkPhysicalDevicePointClippingProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDevicePointClippingProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPointClippingBehavior*)&forUnmarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
+}
+
+void marshal_VkInputAttachmentAspectReference(
+    VulkanStream* vkStream,
+    const VkInputAttachmentAspectReference* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->inputAttachmentIndex, sizeof(uint32_t));
+    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+}
+
+void unmarshal_VkInputAttachmentAspectReference(
+    VulkanStream* vkStream,
+    VkInputAttachmentAspectReference* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentIndex, sizeof(uint32_t));
+    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
+}
+
+void marshal_VkRenderPassInputAttachmentAspectCreateInfo(
+    VulkanStream* vkStream,
+    const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->aspectReferenceCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->aspectReferenceCount; ++i)
+    {
+        marshal_VkInputAttachmentAspectReference(vkStream, (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i));
+    }
+}
+
+void unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
+    VulkanStream* vkStream,
+    VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->aspectReferenceCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pAspectReferences, forUnmarshaling->aspectReferenceCount * sizeof(const VkInputAttachmentAspectReference));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->aspectReferenceCount; ++i)
+    {
+        unmarshal_VkInputAttachmentAspectReference(vkStream, (VkInputAttachmentAspectReference*)(forUnmarshaling->pAspectReferences + i));
+    }
+}
+
+void marshal_VkImageViewUsageCreateInfo(
+    VulkanStream* vkStream,
+    const VkImageViewUsageCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
+}
+
+void unmarshal_VkImageViewUsageCreateInfo(
+    VulkanStream* vkStream,
+    VkImageViewUsageCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
+}
+
+void marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkTessellationDomainOrigin*)&forMarshaling->domainOrigin, sizeof(VkTessellationDomainOrigin));
+}
+
+void unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkTessellationDomainOrigin*)&forUnmarshaling->domainOrigin, sizeof(VkTessellationDomainOrigin));
+}
+
+void marshal_VkRenderPassMultiviewCreateInfo(
+    VulkanStream* vkStream,
+    const VkRenderPassMultiviewCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pViewMasks, forMarshaling->subpassCount * sizeof(const uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
+    vkStream->write((const int32_t*)forMarshaling->pViewOffsets, forMarshaling->dependencyCount * sizeof(const int32_t));
+    vkStream->write((uint32_t*)&forMarshaling->correlationMaskCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pCorrelationMasks, forMarshaling->correlationMaskCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkRenderPassMultiviewCreateInfo(
+    VulkanStream* vkStream,
+    VkRenderPassMultiviewCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pViewMasks, forUnmarshaling->subpassCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pViewMasks, forUnmarshaling->subpassCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pViewOffsets, forUnmarshaling->dependencyCount * sizeof(const int32_t));
+    vkStream->read((int32_t*)forUnmarshaling->pViewOffsets, forUnmarshaling->dependencyCount * sizeof(const int32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->correlationMaskCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pCorrelationMasks, forUnmarshaling->correlationMaskCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pCorrelationMasks, forUnmarshaling->correlationMaskCount * sizeof(const uint32_t));
+}
+
+void marshal_VkPhysicalDeviceMultiviewFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMultiviewFeatures* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->multiview, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->multiviewGeometryShader, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->multiviewTessellationShader, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMultiviewFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMultiviewFeatures* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->multiview, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->multiviewGeometryShader, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->multiviewTessellationShader, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceMultiviewProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMultiviewProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->maxMultiviewViewCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceMultiviewProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMultiviewProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewViewCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
+}
+
+void marshal_VkPhysicalDeviceVariablePointerFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceVariablePointerFeatures* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->variablePointers, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceVariablePointerFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceVariablePointerFeatures* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->variablePointers, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceProtectedMemoryFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->protectedMemory, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->protectedMemory, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceProtectedMemoryProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->protectedNoFault, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->protectedNoFault, sizeof(VkBool32));
+}
+
+void marshal_VkDeviceQueueInfo2(
+    VulkanStream* vkStream,
+    const VkDeviceQueueInfo2* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDeviceQueueCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceQueueCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->queueIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkDeviceQueueInfo2(
+    VulkanStream* vkStream,
+    VkDeviceQueueInfo2* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceQueueCreateFlags*)&forUnmarshaling->flags, sizeof(VkDeviceQueueCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->queueIndex, sizeof(uint32_t));
+}
+
+void marshal_VkProtectedSubmitInfo(
+    VulkanStream* vkStream,
+    const VkProtectedSubmitInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->protectedSubmit, sizeof(VkBool32));
+}
+
+void unmarshal_VkProtectedSubmitInfo(
+    VulkanStream* vkStream,
+    VkProtectedSubmitInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->protectedSubmit, sizeof(VkBool32));
+}
+
+void marshal_VkSamplerYcbcrConversionCreateInfo(
+    VulkanStream* vkStream,
+    const VkSamplerYcbcrConversionCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->ycbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+    vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
+    marshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forMarshaling->components));
+    vkStream->write((VkChromaLocation*)&forMarshaling->xChromaOffset, sizeof(VkChromaLocation));
+    vkStream->write((VkChromaLocation*)&forMarshaling->yChromaOffset, sizeof(VkChromaLocation));
+    vkStream->write((VkFilter*)&forMarshaling->chromaFilter, sizeof(VkFilter));
+    vkStream->write((VkBool32*)&forMarshaling->forceExplicitReconstruction, sizeof(VkBool32));
+}
+
+void unmarshal_VkSamplerYcbcrConversionCreateInfo(
+    VulkanStream* vkStream,
+    VkSamplerYcbcrConversionCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->ycbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+    vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
+    unmarshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forUnmarshaling->components));
+    vkStream->read((VkChromaLocation*)&forUnmarshaling->xChromaOffset, sizeof(VkChromaLocation));
+    vkStream->read((VkChromaLocation*)&forUnmarshaling->yChromaOffset, sizeof(VkChromaLocation));
+    vkStream->read((VkFilter*)&forUnmarshaling->chromaFilter, sizeof(VkFilter));
+    vkStream->read((VkBool32*)&forUnmarshaling->forceExplicitReconstruction, sizeof(VkBool32));
+}
+
+void marshal_VkSamplerYcbcrConversionInfo(
+    VulkanStream* vkStream,
+    const VkSamplerYcbcrConversionInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_164;
+    vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion, &cgen_var_164, 1);
+    vkStream->write((uint64_t*)&cgen_var_164, 1 * 8);
+}
+
+void unmarshal_VkSamplerYcbcrConversionInfo(
+    VulkanStream* vkStream,
+    VkSamplerYcbcrConversionInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, 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_VkSamplerYcbcrConversion(&cgen_var_165, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
+}
+
+void marshal_VkBindImagePlaneMemoryInfo(
+    VulkanStream* vkStream,
+    const VkBindImagePlaneMemoryInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+}
+
+void unmarshal_VkBindImagePlaneMemoryInfo(
+    VulkanStream* vkStream,
+    VkBindImagePlaneMemoryInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+}
+
+void marshal_VkImagePlaneMemoryRequirementsInfo(
+    VulkanStream* vkStream,
+    const VkImagePlaneMemoryRequirementsInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+}
+
+void unmarshal_VkImagePlaneMemoryRequirementsInfo(
+    VulkanStream* vkStream,
+    VkImagePlaneMemoryRequirementsInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+}
+
+void marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->samplerYcbcrConversion, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->samplerYcbcrConversion, sizeof(VkBool32));
+}
+
+void marshal_VkSamplerYcbcrConversionImageFormatProperties(
+    VulkanStream* vkStream,
+    const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->combinedImageSamplerDescriptorCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
+    VulkanStream* vkStream,
+    VkSamplerYcbcrConversionImageFormatProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->combinedImageSamplerDescriptorCount, sizeof(uint32_t));
+}
+
+void marshal_VkDescriptorUpdateTemplateEntry(
+    VulkanStream* vkStream,
+    const VkDescriptorUpdateTemplateEntry* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
+    vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
+    uint64_t cgen_var_166 = (uint64_t)forMarshaling->offset;
+    vkStream->putBe64(cgen_var_166);
+    uint64_t cgen_var_167 = (uint64_t)forMarshaling->stride;
+    vkStream->putBe64(cgen_var_167);
+}
+
+void unmarshal_VkDescriptorUpdateTemplateEntry(
+    VulkanStream* vkStream,
+    VkDescriptorUpdateTemplateEntry* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
+    vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
+    forUnmarshaling->offset = (size_t)vkStream->getBe64();
+    forUnmarshaling->stride = (size_t)vkStream->getBe64();
+}
+
+void marshal_VkDescriptorUpdateTemplateCreateInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorUpdateTemplateCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDescriptorUpdateTemplateCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorUpdateTemplateCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorUpdateEntryCount; ++i)
+    {
+        marshal_VkDescriptorUpdateTemplateEntry(vkStream, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i));
+    }
+    vkStream->write((VkDescriptorUpdateTemplateType*)&forMarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
+    uint64_t cgen_var_170;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&forMarshaling->descriptorSetLayout, &cgen_var_170, 1);
+    vkStream->write((uint64_t*)&cgen_var_170, 1 * 8);
+    vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    uint64_t cgen_var_171;
+    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_171, 1);
+    vkStream->write((uint64_t*)&cgen_var_171, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->set, sizeof(uint32_t));
+}
+
+void unmarshal_VkDescriptorUpdateTemplateCreateInfo(
+    VulkanStream* vkStream,
+    VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDescriptorUpdateTemplateCreateFlags*)&forUnmarshaling->flags, sizeof(VkDescriptorUpdateTemplateCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDescriptorUpdateEntries, forUnmarshaling->descriptorUpdateEntryCount * sizeof(const VkDescriptorUpdateTemplateEntry));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorUpdateEntryCount; ++i)
+    {
+        unmarshal_VkDescriptorUpdateTemplateEntry(vkStream, (VkDescriptorUpdateTemplateEntry*)(forUnmarshaling->pDescriptorUpdateEntries + i));
+    }
+    vkStream->read((VkDescriptorUpdateTemplateType*)&forUnmarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
+    uint64_t cgen_var_172;
+    vkStream->read((uint64_t*)&cgen_var_172, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_172, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
+    vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    uint64_t cgen_var_173;
+    vkStream->read((uint64_t*)&cgen_var_173, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_173, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->set, sizeof(uint32_t));
+}
+
+void marshal_VkExternalMemoryProperties(
+    VulkanStream* vkStream,
+    const VkExternalMemoryProperties* forMarshaling)
+{
+    vkStream->write((VkExternalMemoryFeatureFlags*)&forMarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlags));
+    vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+    vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void unmarshal_VkExternalMemoryProperties(
+    VulkanStream* vkStream,
+    VkExternalMemoryProperties* forUnmarshaling)
+{
+    vkStream->read((VkExternalMemoryFeatureFlags*)&forUnmarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlags));
+    vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+    vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void marshal_VkPhysicalDeviceExternalImageFormatInfo(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void marshal_VkExternalImageFormatProperties(
+    VulkanStream* vkStream,
+    const VkExternalImageFormatProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
+}
+
+void unmarshal_VkExternalImageFormatProperties(
+    VulkanStream* vkStream,
+    VkExternalImageFormatProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
+}
+
+void marshal_VkPhysicalDeviceExternalBufferInfo(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceExternalBufferInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
+    vkStream->write((VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
+    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void unmarshal_VkPhysicalDeviceExternalBufferInfo(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceExternalBufferInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferCreateFlags));
+    vkStream->read((VkBufferUsageFlags*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags));
+    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void marshal_VkExternalBufferProperties(
+    VulkanStream* vkStream,
+    const VkExternalBufferProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
+}
+
+void unmarshal_VkExternalBufferProperties(
+    VulkanStream* vkStream,
+    VkExternalBufferProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
+}
+
+void marshal_VkPhysicalDeviceIDProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceIDProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint8_t*)forMarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    vkStream->write((uint8_t*)forMarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    vkStream->write((uint8_t*)forMarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
+    vkStream->write((uint32_t*)&forMarshaling->deviceNodeMask, sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->deviceLUIDValid, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceIDProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceIDProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint8_t*)forUnmarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    vkStream->read((uint8_t*)forUnmarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    vkStream->read((uint8_t*)forUnmarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceNodeMask, sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->deviceLUIDValid, sizeof(VkBool32));
+}
+
+void marshal_VkExternalMemoryImageCreateInfo(
+    VulkanStream* vkStream,
+    const VkExternalMemoryImageCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void unmarshal_VkExternalMemoryImageCreateInfo(
+    VulkanStream* vkStream,
+    VkExternalMemoryImageCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void marshal_VkExternalMemoryBufferCreateInfo(
+    VulkanStream* vkStream,
+    const VkExternalMemoryBufferCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void unmarshal_VkExternalMemoryBufferCreateInfo(
+    VulkanStream* vkStream,
+    VkExternalMemoryBufferCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void marshal_VkExportMemoryAllocateInfo(
+    VulkanStream* vkStream,
+    const VkExportMemoryAllocateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void unmarshal_VkExportMemoryAllocateInfo(
+    VulkanStream* vkStream,
+    VkExportMemoryAllocateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void marshal_VkPhysicalDeviceExternalFenceInfo(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceExternalFenceInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+void unmarshal_VkPhysicalDeviceExternalFenceInfo(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceExternalFenceInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+void marshal_VkExternalFenceProperties(
+    VulkanStream* vkStream,
+    const VkExternalFenceProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+    vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+    vkStream->write((VkExternalFenceFeatureFlags*)&forMarshaling->externalFenceFeatures, sizeof(VkExternalFenceFeatureFlags));
+}
+
+void unmarshal_VkExternalFenceProperties(
+    VulkanStream* vkStream,
+    VkExternalFenceProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+    vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+    vkStream->read((VkExternalFenceFeatureFlags*)&forUnmarshaling->externalFenceFeatures, sizeof(VkExternalFenceFeatureFlags));
+}
+
+void marshal_VkExportFenceCreateInfo(
+    VulkanStream* vkStream,
+    const VkExportFenceCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+}
+
+void unmarshal_VkExportFenceCreateInfo(
+    VulkanStream* vkStream,
+    VkExportFenceCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+}
+
+void marshal_VkExportSemaphoreCreateInfo(
+    VulkanStream* vkStream,
+    const VkExportSemaphoreCreateInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+}
+
+void unmarshal_VkExportSemaphoreCreateInfo(
+    VulkanStream* vkStream,
+    VkExportSemaphoreCreateInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+}
+
+void marshal_VkPhysicalDeviceExternalSemaphoreInfo(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+void unmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+void marshal_VkExternalSemaphoreProperties(
+    VulkanStream* vkStream,
+    const VkExternalSemaphoreProperties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+    vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+    vkStream->write((VkExternalSemaphoreFeatureFlags*)&forMarshaling->externalSemaphoreFeatures, sizeof(VkExternalSemaphoreFeatureFlags));
+}
+
+void unmarshal_VkExternalSemaphoreProperties(
+    VulkanStream* vkStream,
+    VkExternalSemaphoreProperties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+    vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+    vkStream->read((VkExternalSemaphoreFeatureFlags*)&forUnmarshaling->externalSemaphoreFeatures, sizeof(VkExternalSemaphoreFeatureFlags));
+}
+
+void marshal_VkPhysicalDeviceMaintenance3Properties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMaintenance3Properties* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->maxPerSetDescriptors, sizeof(uint32_t));
+    vkStream->write((VkDeviceSize*)&forMarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkPhysicalDeviceMaintenance3Properties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMaintenance3Properties* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerSetDescriptors, sizeof(uint32_t));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
+}
+
+void marshal_VkDescriptorSetLayoutSupport(
+    VulkanStream* vkStream,
+    const VkDescriptorSetLayoutSupport* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->supported, sizeof(VkBool32));
+}
+
+void unmarshal_VkDescriptorSetLayoutSupport(
+    VulkanStream* vkStream,
+    VkDescriptorSetLayoutSupport* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->supported, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceShaderDrawParameterFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceShaderDrawParameterFeatures* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->shaderDrawParameters, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderDrawParameterFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceShaderDrawParameterFeatures* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderDrawParameters, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_KHR_surface
+void marshal_VkSurfaceCapabilitiesKHR(
+    VulkanStream* vkStream,
+    const VkSurfaceCapabilitiesKHR* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxImageCount, sizeof(uint32_t));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->currentExtent));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minImageExtent));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxImageExtent));
+    vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
+    vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+    vkStream->write((VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
+    vkStream->write((VkImageUsageFlags*)&forMarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+}
+
+void unmarshal_VkSurfaceCapabilitiesKHR(
+    VulkanStream* vkStream,
+    VkSurfaceCapabilitiesKHR* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxImageCount, sizeof(uint32_t));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->currentExtent));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->minImageExtent));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxImageExtent));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
+    vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+    vkStream->read((VkCompositeAlphaFlagsKHR*)&forUnmarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
+    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+}
+
+void marshal_VkSurfaceFormatKHR(
+    VulkanStream* vkStream,
+    const VkSurfaceFormatKHR* forMarshaling)
+{
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    vkStream->write((VkColorSpaceKHR*)&forMarshaling->colorSpace, sizeof(VkColorSpaceKHR));
+}
+
+void unmarshal_VkSurfaceFormatKHR(
+    VulkanStream* vkStream,
+    VkSurfaceFormatKHR* forUnmarshaling)
+{
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->colorSpace, sizeof(VkColorSpaceKHR));
+}
+
+#endif
+#ifdef VK_KHR_swapchain
+void marshal_VkSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkSwapchainCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkSwapchainCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
+    uint64_t cgen_var_174;
+    vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_174, 1);
+    vkStream->write((uint64_t*)&cgen_var_174, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
+    vkStream->write((VkFormat*)&forMarshaling->imageFormat, sizeof(VkFormat));
+    vkStream->write((VkColorSpaceKHR*)&forMarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->imageExtent));
+    vkStream->write((uint32_t*)&forMarshaling->imageArrayLayers, sizeof(uint32_t));
+    vkStream->write((VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
+    vkStream->write((VkSharingMode*)&forMarshaling->imageSharingMode, sizeof(VkSharingMode));
+    vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_175 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+    vkStream->putBe64(cgen_var_175);
+    if (forMarshaling->pQueueFamilyIndices)
+    {
+        vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+    }
+    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->preTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+    vkStream->write((VkCompositeAlphaFlagBitsKHR*)&forMarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
+    vkStream->write((VkPresentModeKHR*)&forMarshaling->presentMode, sizeof(VkPresentModeKHR));
+    vkStream->write((VkBool32*)&forMarshaling->clipped, sizeof(VkBool32));
+    uint64_t cgen_var_176;
+    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->oldSwapchain, &cgen_var_176, 1);
+    vkStream->write((uint64_t*)&cgen_var_176, 1 * 8);
+}
+
+void unmarshal_VkSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkSwapchainCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkSwapchainCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
+    uint64_t cgen_var_177;
+    vkStream->read((uint64_t*)&cgen_var_177, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_177, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
+    vkStream->read((VkFormat*)&forUnmarshaling->imageFormat, sizeof(VkFormat));
+    vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->imageExtent));
+    vkStream->read((uint32_t*)&forUnmarshaling->imageArrayLayers, sizeof(uint32_t));
+    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->imageUsage, sizeof(VkImageUsageFlags));
+    vkStream->read((VkSharingMode*)&forUnmarshaling->imageSharingMode, sizeof(VkSharingMode));
+    vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pQueueFamilyIndices)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+        vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+    }
+    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->preTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+    vkStream->read((VkCompositeAlphaFlagBitsKHR*)&forUnmarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
+    vkStream->read((VkPresentModeKHR*)&forUnmarshaling->presentMode, sizeof(VkPresentModeKHR));
+    vkStream->read((VkBool32*)&forUnmarshaling->clipped, sizeof(VkBool32));
+    uint64_t cgen_var_179;
+    vkStream->read((uint64_t*)&cgen_var_179, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_179, (VkSwapchainKHR*)&forUnmarshaling->oldSwapchain, 1);
+}
+
+void marshal_VkPresentInfoKHR(
+    VulkanStream* vkStream,
+    const VkPresentInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
+    if (forMarshaling->waitSemaphoreCount)
+    {
+        uint64_t* cgen_var_180;
+        vkStream->alloc((void**)&cgen_var_180, forMarshaling->waitSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_180, forMarshaling->waitSemaphoreCount);
+        vkStream->write((uint64_t*)cgen_var_180, forMarshaling->waitSemaphoreCount * 8);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
+    if (forMarshaling->swapchainCount)
+    {
+        uint64_t* cgen_var_181;
+        vkStream->alloc((void**)&cgen_var_181, forMarshaling->swapchainCount * 8);
+        vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(forMarshaling->pSwapchains, cgen_var_181, forMarshaling->swapchainCount);
+        vkStream->write((uint64_t*)cgen_var_181, forMarshaling->swapchainCount * 8);
+    }
+    vkStream->write((const uint32_t*)forMarshaling->pImageIndices, forMarshaling->swapchainCount * sizeof(const uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_182 = (uint64_t)(uintptr_t)forMarshaling->pResults;
+    vkStream->putBe64(cgen_var_182);
+    if (forMarshaling->pResults)
+    {
+        vkStream->write((VkResult*)forMarshaling->pResults, forMarshaling->swapchainCount * sizeof(VkResult));
+    }
+}
+
+void unmarshal_VkPresentInfoKHR(
+    VulkanStream* vkStream,
+    VkPresentInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount * sizeof(const VkSemaphore));
+    if (forUnmarshaling->waitSemaphoreCount)
+    {
+        uint64_t* cgen_var_183;
+        vkStream->alloc((void**)&cgen_var_183, forUnmarshaling->waitSemaphoreCount * 8);
+        vkStream->read((uint64_t*)cgen_var_183, forUnmarshaling->waitSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_183, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSwapchains, forUnmarshaling->swapchainCount * sizeof(const VkSwapchainKHR));
+    if (forUnmarshaling->swapchainCount)
+    {
+        uint64_t* cgen_var_184;
+        vkStream->alloc((void**)&cgen_var_184, forUnmarshaling->swapchainCount * 8);
+        vkStream->read((uint64_t*)cgen_var_184, forUnmarshaling->swapchainCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_184, (VkSwapchainKHR*)forUnmarshaling->pSwapchains, forUnmarshaling->swapchainCount);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pImageIndices, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pImageIndices, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pResults = (VkResult*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pResults)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pResults, forUnmarshaling->swapchainCount * sizeof(VkResult));
+        vkStream->read((VkResult*)forUnmarshaling->pResults, forUnmarshaling->swapchainCount * sizeof(VkResult));
+    }
+}
+
+void marshal_VkImageSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkImageSwapchainCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_186;
+    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_186, 1);
+    vkStream->write((uint64_t*)&cgen_var_186, 1 * 8);
+}
+
+void unmarshal_VkImageSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkImageSwapchainCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_187;
+    vkStream->read((uint64_t*)&cgen_var_187, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_187, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+}
+
+void marshal_VkBindImageMemorySwapchainInfoKHR(
+    VulkanStream* vkStream,
+    const VkBindImageMemorySwapchainInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_188;
+    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_188, 1);
+    vkStream->write((uint64_t*)&cgen_var_188, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->imageIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkBindImageMemorySwapchainInfoKHR(
+    VulkanStream* vkStream,
+    VkBindImageMemorySwapchainInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_189;
+    vkStream->read((uint64_t*)&cgen_var_189, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_189, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->imageIndex, sizeof(uint32_t));
+}
+
+void marshal_VkAcquireNextImageInfoKHR(
+    VulkanStream* vkStream,
+    const VkAcquireNextImageInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        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);
+    vkStream->write((uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
+    uint64_t cgen_var_191;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_191, 1);
+    vkStream->write((uint64_t*)&cgen_var_191, 1 * 8);
+    uint64_t cgen_var_192;
+    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_192, 1);
+    vkStream->write((uint64_t*)&cgen_var_192, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void unmarshal_VkAcquireNextImageInfoKHR(
+    VulkanStream* vkStream,
+    VkAcquireNextImageInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, 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);
+    vkStream->read((uint64_t*)&forUnmarshaling->timeout, sizeof(uint64_t));
+    uint64_t cgen_var_194;
+    vkStream->read((uint64_t*)&cgen_var_194, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_194, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    uint64_t cgen_var_195;
+    vkStream->read((uint64_t*)&cgen_var_195, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_195, (VkFence*)&forUnmarshaling->fence, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void marshal_VkDeviceGroupPresentCapabilitiesKHR(
+    VulkanStream* vkStream,
+    const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)forMarshaling->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
+    vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+}
+
+void unmarshal_VkDeviceGroupPresentCapabilitiesKHR(
+    VulkanStream* vkStream,
+    VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)forUnmarshaling->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
+    vkStream->read((VkDeviceGroupPresentModeFlagsKHR*)&forUnmarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+}
+
+void marshal_VkDeviceGroupPresentInfoKHR(
+    VulkanStream* vkStream,
+    const VkDeviceGroupPresentInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pDeviceMasks, forMarshaling->swapchainCount * sizeof(const uint32_t));
+    vkStream->write((VkDeviceGroupPresentModeFlagBitsKHR*)&forMarshaling->mode, sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
+}
+
+void unmarshal_VkDeviceGroupPresentInfoKHR(
+    VulkanStream* vkStream,
+    VkDeviceGroupPresentInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDeviceMasks, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pDeviceMasks, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
+    vkStream->read((VkDeviceGroupPresentModeFlagBitsKHR*)&forUnmarshaling->mode, sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
+}
+
+void marshal_VkDeviceGroupSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+}
+
+void unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceGroupPresentModeFlagsKHR*)&forUnmarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+}
+
+#endif
+#ifdef VK_KHR_display
+void marshal_VkDisplayPropertiesKHR(
+    VulkanStream* vkStream,
+    const VkDisplayPropertiesKHR* forMarshaling)
+{
+    uint64_t cgen_var_196;
+    vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->display, &cgen_var_196, 1);
+    vkStream->write((uint64_t*)&cgen_var_196, 1 * 8);
+    vkStream->putString(forMarshaling->displayName);
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalDimensions));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalResolution));
+    vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+    vkStream->write((VkBool32*)&forMarshaling->planeReorderPossible, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->persistentContent, sizeof(VkBool32));
+}
+
+void unmarshal_VkDisplayPropertiesKHR(
+    VulkanStream* vkStream,
+    VkDisplayPropertiesKHR* forUnmarshaling)
+{
+    uint64_t cgen_var_197;
+    vkStream->read((uint64_t*)&cgen_var_197, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_197, (VkDisplayKHR*)&forUnmarshaling->display, 1);
+    vkStream->loadStringInPlace((char**)&forUnmarshaling->displayName);
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalDimensions));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalResolution));
+    vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+    vkStream->read((VkBool32*)&forUnmarshaling->planeReorderPossible, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->persistentContent, sizeof(VkBool32));
+}
+
+void marshal_VkDisplayModeParametersKHR(
+    VulkanStream* vkStream,
+    const VkDisplayModeParametersKHR* forMarshaling)
+{
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->visibleRegion));
+    vkStream->write((uint32_t*)&forMarshaling->refreshRate, sizeof(uint32_t));
+}
+
+void unmarshal_VkDisplayModeParametersKHR(
+    VulkanStream* vkStream,
+    VkDisplayModeParametersKHR* forUnmarshaling)
+{
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->visibleRegion));
+    vkStream->read((uint32_t*)&forUnmarshaling->refreshRate, sizeof(uint32_t));
+}
+
+void marshal_VkDisplayModePropertiesKHR(
+    VulkanStream* vkStream,
+    const VkDisplayModePropertiesKHR* forMarshaling)
+{
+    uint64_t cgen_var_198;
+    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_198, 1);
+    vkStream->write((uint64_t*)&cgen_var_198, 1 * 8);
+    marshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
+}
+
+void unmarshal_VkDisplayModePropertiesKHR(
+    VulkanStream* vkStream,
+    VkDisplayModePropertiesKHR* forUnmarshaling)
+{
+    uint64_t cgen_var_199;
+    vkStream->read((uint64_t*)&cgen_var_199, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_199, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
+    unmarshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
+}
+
+void marshal_VkDisplayModeCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkDisplayModeCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDisplayModeCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplayModeCreateFlagsKHR));
+    marshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
+}
+
+void unmarshal_VkDisplayModeCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkDisplayModeCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDisplayModeCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplayModeCreateFlagsKHR));
+    unmarshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
+}
+
+void marshal_VkDisplayPlaneCapabilitiesKHR(
+    VulkanStream* vkStream,
+    const VkDisplayPlaneCapabilitiesKHR* forMarshaling)
+{
+    vkStream->write((VkDisplayPlaneAlphaFlagsKHR*)&forMarshaling->supportedAlpha, sizeof(VkDisplayPlaneAlphaFlagsKHR));
+    marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->minSrcPosition));
+    marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->maxSrcPosition));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minSrcExtent));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxSrcExtent));
+    marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->minDstPosition));
+    marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->maxDstPosition));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minDstExtent));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxDstExtent));
+}
+
+void unmarshal_VkDisplayPlaneCapabilitiesKHR(
+    VulkanStream* vkStream,
+    VkDisplayPlaneCapabilitiesKHR* forUnmarshaling)
+{
+    vkStream->read((VkDisplayPlaneAlphaFlagsKHR*)&forUnmarshaling->supportedAlpha, sizeof(VkDisplayPlaneAlphaFlagsKHR));
+    unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->minSrcPosition));
+    unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->maxSrcPosition));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->minSrcExtent));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxSrcExtent));
+    unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->minDstPosition));
+    unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->maxDstPosition));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->minDstExtent));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxDstExtent));
+}
+
+void marshal_VkDisplayPlanePropertiesKHR(
+    VulkanStream* vkStream,
+    const VkDisplayPlanePropertiesKHR* forMarshaling)
+{
+    uint64_t cgen_var_200;
+    vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->currentDisplay, &cgen_var_200, 1);
+    vkStream->write((uint64_t*)&cgen_var_200, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->currentStackIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkDisplayPlanePropertiesKHR(
+    VulkanStream* vkStream,
+    VkDisplayPlanePropertiesKHR* 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->currentDisplay, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->currentStackIndex, sizeof(uint32_t));
+}
+
+void marshal_VkDisplaySurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkDisplaySurfaceCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
+    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);
+    vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->planeStackIndex, sizeof(uint32_t));
+    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+    vkStream->write((float*)&forMarshaling->globalAlpha, sizeof(float));
+    vkStream->write((VkDisplayPlaneAlphaFlagBitsKHR*)&forMarshaling->alphaMode, sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->imageExtent));
+}
+
+void unmarshal_VkDisplaySurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkDisplaySurfaceCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDisplaySurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
+    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);
+    vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->planeStackIndex, sizeof(uint32_t));
+    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+    vkStream->read((float*)&forUnmarshaling->globalAlpha, sizeof(float));
+    vkStream->read((VkDisplayPlaneAlphaFlagBitsKHR*)&forUnmarshaling->alphaMode, sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->imageExtent));
+}
+
+#endif
+#ifdef VK_KHR_display_swapchain
+void marshal_VkDisplayPresentInfoKHR(
+    VulkanStream* vkStream,
+    const VkDisplayPresentInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->srcRect));
+    marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->dstRect));
+    vkStream->write((VkBool32*)&forMarshaling->persistent, sizeof(VkBool32));
+}
+
+void unmarshal_VkDisplayPresentInfoKHR(
+    VulkanStream* vkStream,
+    VkDisplayPresentInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->srcRect));
+    unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->dstRect));
+    vkStream->read((VkBool32*)&forUnmarshaling->persistent, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_KHR_xlib_surface
+void marshal_VkXlibSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkXlibSurfaceCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_204 = (uint64_t)(uintptr_t)forMarshaling->dpy;
+    vkStream->putBe64(cgen_var_204);
+    if (forMarshaling->dpy)
+    {
+        vkStream->write((Display*)forMarshaling->dpy, sizeof(Display));
+    }
+    vkStream->write((Window*)&forMarshaling->window, sizeof(Window));
+}
+
+void unmarshal_VkXlibSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkXlibSurfaceCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkXlibSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
+    // WARNING PTR CHECK
+    forUnmarshaling->dpy = (Display*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->dpy)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->dpy, sizeof(Display));
+        vkStream->read((Display*)forUnmarshaling->dpy, sizeof(Display));
+    }
+    vkStream->read((Window*)&forUnmarshaling->window, sizeof(Window));
+}
+
+#endif
+#ifdef VK_KHR_xcb_surface
+void marshal_VkXcbSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkXcbSurfaceCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkXcbSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_206 = (uint64_t)(uintptr_t)forMarshaling->connection;
+    vkStream->putBe64(cgen_var_206);
+    if (forMarshaling->connection)
+    {
+        vkStream->write((xcb_connection_t*)forMarshaling->connection, sizeof(xcb_connection_t));
+    }
+    vkStream->write((xcb_window_t*)&forMarshaling->window, sizeof(xcb_window_t));
+}
+
+void unmarshal_VkXcbSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkXcbSurfaceCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkXcbSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
+    // WARNING PTR CHECK
+    forUnmarshaling->connection = (xcb_connection_t*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->connection)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->connection, sizeof(xcb_connection_t));
+        vkStream->read((xcb_connection_t*)forUnmarshaling->connection, sizeof(xcb_connection_t));
+    }
+    vkStream->read((xcb_window_t*)&forUnmarshaling->window, sizeof(xcb_window_t));
+}
+
+#endif
+#ifdef VK_KHR_wayland_surface
+void marshal_VkWaylandSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkWaylandSurfaceCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_208 = (uint64_t)(uintptr_t)forMarshaling->display;
+    vkStream->putBe64(cgen_var_208);
+    if (forMarshaling->display)
+    {
+        vkStream->write((wl_display*)forMarshaling->display, sizeof(wl_display));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_209 = (uint64_t)(uintptr_t)forMarshaling->surface;
+    vkStream->putBe64(cgen_var_209);
+    if (forMarshaling->surface)
+    {
+        vkStream->write((wl_surface*)forMarshaling->surface, sizeof(wl_surface));
+    }
+}
+
+void unmarshal_VkWaylandSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkWaylandSurfaceCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkWaylandSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
+    // WARNING PTR CHECK
+    forUnmarshaling->display = (wl_display*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->display)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->display, sizeof(wl_display));
+        vkStream->read((wl_display*)forUnmarshaling->display, sizeof(wl_display));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->surface = (wl_surface*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->surface)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->surface, sizeof(wl_surface));
+        vkStream->read((wl_surface*)forUnmarshaling->surface, sizeof(wl_surface));
+    }
+}
+
+#endif
+#ifdef VK_KHR_mir_surface
+void marshal_VkMirSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkMirSurfaceCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkMirSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkMirSurfaceCreateFlagsKHR));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_212 = (uint64_t)(uintptr_t)forMarshaling->connection;
+    vkStream->putBe64(cgen_var_212);
+    if (forMarshaling->connection)
+    {
+        vkStream->write((MirConnection*)forMarshaling->connection, sizeof(MirConnection));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_213 = (uint64_t)(uintptr_t)forMarshaling->mirSurface;
+    vkStream->putBe64(cgen_var_213);
+    if (forMarshaling->mirSurface)
+    {
+        vkStream->write((MirSurface*)forMarshaling->mirSurface, sizeof(MirSurface));
+    }
+}
+
+void unmarshal_VkMirSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkMirSurfaceCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkMirSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkMirSurfaceCreateFlagsKHR));
+    // WARNING PTR CHECK
+    forUnmarshaling->connection = (MirConnection*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->connection)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->connection, sizeof(MirConnection));
+        vkStream->read((MirConnection*)forUnmarshaling->connection, sizeof(MirConnection));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->mirSurface = (MirSurface*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->mirSurface)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->mirSurface, sizeof(MirSurface));
+        vkStream->read((MirSurface*)forUnmarshaling->mirSurface, sizeof(MirSurface));
+    }
+}
+
+#endif
+#ifdef VK_KHR_android_surface
+void marshal_VkAndroidSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkAndroidSurfaceCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_216 = (uint64_t)(uintptr_t)forMarshaling->window;
+    vkStream->putBe64(cgen_var_216);
+    if (forMarshaling->window)
+    {
+        vkStream->write((ANativeWindow*)forMarshaling->window, sizeof(ANativeWindow));
+    }
+}
+
+void unmarshal_VkAndroidSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkAndroidSurfaceCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkAndroidSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
+    // WARNING PTR CHECK
+    forUnmarshaling->window = (ANativeWindow*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->window)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->window, sizeof(ANativeWindow));
+        vkStream->read((ANativeWindow*)forUnmarshaling->window, sizeof(ANativeWindow));
+    }
+}
+
+#endif
+#ifdef VK_KHR_win32_surface
+void marshal_VkWin32SurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkWin32SurfaceCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkWin32SurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWin32SurfaceCreateFlagsKHR));
+    vkStream->write((HINSTANCE*)&forMarshaling->hinstance, sizeof(HINSTANCE));
+    vkStream->write((HWND*)&forMarshaling->hwnd, sizeof(HWND));
+}
+
+void unmarshal_VkWin32SurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkWin32SurfaceCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkWin32SurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkWin32SurfaceCreateFlagsKHR));
+    vkStream->read((HINSTANCE*)&forUnmarshaling->hinstance, sizeof(HINSTANCE));
+    vkStream->read((HWND*)&forUnmarshaling->hwnd, sizeof(HWND));
+}
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void marshal_VkImportMemoryWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportMemoryWin32HandleInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+    vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
+    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkImportMemoryWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkImportMemoryWin32HandleInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+    vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
+    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkExportMemoryWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkExportMemoryWin32HandleInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_218 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+    vkStream->putBe64(cgen_var_218);
+    if (forMarshaling->pAttributes)
+    {
+        vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+    vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
+    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkExportMemoryWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkExportMemoryWin32HandleInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pAttributes)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+        vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+    vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
+    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkMemoryWin32HandlePropertiesKHR(
+    VulkanStream* vkStream,
+    const VkMemoryWin32HandlePropertiesKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryWin32HandlePropertiesKHR(
+    VulkanStream* vkStream,
+    VkMemoryWin32HandlePropertiesKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkMemoryGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkMemoryGetWin32HandleInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_220;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_220, 1);
+    vkStream->write((uint64_t*)&cgen_var_220, 1 * 8);
+    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void unmarshal_VkMemoryGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkMemoryGetWin32HandleInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_221;
+    vkStream->read((uint64_t*)&cgen_var_221, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_221, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+void marshal_VkImportMemoryFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportMemoryFdInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+    vkStream->write((int*)&forMarshaling->fd, sizeof(int));
+}
+
+void unmarshal_VkImportMemoryFdInfoKHR(
+    VulkanStream* vkStream,
+    VkImportMemoryFdInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+    vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
+}
+
+void marshal_VkMemoryFdPropertiesKHR(
+    VulkanStream* vkStream,
+    const VkMemoryFdPropertiesKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryFdPropertiesKHR(
+    VulkanStream* vkStream,
+    VkMemoryFdPropertiesKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkMemoryGetFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkMemoryGetFdInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_222;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_222, 1);
+    vkStream->write((uint64_t*)&cgen_var_222, 1 * 8);
+    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void unmarshal_VkMemoryGetFdInfoKHR(
+    VulkanStream* vkStream,
+    VkMemoryGetFdInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_223;
+    vkStream->read((uint64_t*)&cgen_var_223, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_223, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+    VulkanStream* vkStream,
+    const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
+    if (forMarshaling->acquireCount)
+    {
+        uint64_t* cgen_var_224;
+        vkStream->alloc((void**)&cgen_var_224, forMarshaling->acquireCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_224, forMarshaling->acquireCount);
+        vkStream->write((uint64_t*)cgen_var_224, 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_225;
+        vkStream->alloc((void**)&cgen_var_225, forMarshaling->releaseCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_225, forMarshaling->releaseCount);
+        vkStream->write((uint64_t*)cgen_var_225, forMarshaling->releaseCount * 8);
+    }
+    vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
+}
+
+void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+    VulkanStream* vkStream,
+    VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount * sizeof(const VkDeviceMemory));
+    if (forUnmarshaling->acquireCount)
+    {
+        uint64_t* cgen_var_226;
+        vkStream->alloc((void**)&cgen_var_226, forUnmarshaling->acquireCount * 8);
+        vkStream->read((uint64_t*)cgen_var_226, forUnmarshaling->acquireCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_226, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
+    vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
+    vkStream->alloc((void**)&forUnmarshaling->pAcquireTimeouts, forUnmarshaling->acquireCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeouts, forUnmarshaling->acquireCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount * sizeof(const VkDeviceMemory));
+    if (forUnmarshaling->releaseCount)
+    {
+        uint64_t* cgen_var_227;
+        vkStream->alloc((void**)&cgen_var_227, forUnmarshaling->releaseCount * 8);
+        vkStream->read((uint64_t*)cgen_var_227, forUnmarshaling->releaseCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_227, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
+    vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void marshal_VkImportSemaphoreWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_228;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_228, 1);
+    vkStream->write((uint64_t*)&cgen_var_228, 1 * 8);
+    vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
+    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+    vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
+    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkImportSemaphoreWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_229;
+    vkStream->read((uint64_t*)&cgen_var_229, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_229, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
+    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+    vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
+    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkExportSemaphoreWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_230 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+    vkStream->putBe64(cgen_var_230);
+    if (forMarshaling->pAttributes)
+    {
+        vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+    vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
+    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pAttributes)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+        vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+    vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
+    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkD3D12FenceSubmitInfoKHR(
+    VulkanStream* vkStream,
+    const VkD3D12FenceSubmitInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_232 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
+    vkStream->putBe64(cgen_var_232);
+    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_233 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
+    vkStream->putBe64(cgen_var_233);
+    if (forMarshaling->pSignalSemaphoreValues)
+    {
+        vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues, forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
+    }
+}
+
+void unmarshal_VkD3D12FenceSubmitInfoKHR(
+    VulkanStream* vkStream,
+    VkD3D12FenceSubmitInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pWaitSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pWaitSemaphoreValues)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphoreValues, forUnmarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
+        vkStream->read((uint64_t*)forUnmarshaling->pWaitSemaphoreValues, forUnmarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pSignalSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pSignalSemaphoreValues)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphoreValues, forUnmarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
+        vkStream->read((uint64_t*)forUnmarshaling->pSignalSemaphoreValues, forUnmarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
+    }
+}
+
+void marshal_VkSemaphoreGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_236;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_236, 1);
+    vkStream->write((uint64_t*)&cgen_var_236, 1 * 8);
+    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_237;
+    vkStream->read((uint64_t*)&cgen_var_237, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_237, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void marshal_VkImportSemaphoreFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportSemaphoreFdInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_238;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_238, 1);
+    vkStream->write((uint64_t*)&cgen_var_238, 1 * 8);
+    vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
+    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+    vkStream->write((int*)&forMarshaling->fd, sizeof(int));
+}
+
+void unmarshal_VkImportSemaphoreFdInfoKHR(
+    VulkanStream* vkStream,
+    VkImportSemaphoreFdInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_239;
+    vkStream->read((uint64_t*)&cgen_var_239, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_239, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
+    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+    vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
+}
+
+void marshal_VkSemaphoreGetFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkSemaphoreGetFdInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        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);
+    vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+void unmarshal_VkSemaphoreGetFdInfoKHR(
+    VulkanStream* vkStream,
+    VkSemaphoreGetFdInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, 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);
+    vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+    VulkanStream* vkStream,
+    const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+    VulkanStream* vkStream,
+    VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPushDescriptors, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void marshal_VkRectLayerKHR(
+    VulkanStream* vkStream,
+    const VkRectLayerKHR* forMarshaling)
+{
+    marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->offset));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->extent));
+    vkStream->write((uint32_t*)&forMarshaling->layer, sizeof(uint32_t));
+}
+
+void unmarshal_VkRectLayerKHR(
+    VulkanStream* vkStream,
+    VkRectLayerKHR* forUnmarshaling)
+{
+    unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->offset));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->extent));
+    vkStream->read((uint32_t*)&forUnmarshaling->layer, sizeof(uint32_t));
+}
+
+void marshal_VkPresentRegionKHR(
+    VulkanStream* vkStream,
+    const VkPresentRegionKHR* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->rectangleCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_242 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
+    vkStream->putBe64(cgen_var_242);
+    if (forMarshaling->pRectangles)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i)
+        {
+            marshal_VkRectLayerKHR(vkStream, (const VkRectLayerKHR*)(forMarshaling->pRectangles + i));
+        }
+    }
+}
+
+void unmarshal_VkPresentRegionKHR(
+    VulkanStream* vkStream,
+    VkPresentRegionKHR* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->rectangleCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pRectangles = (const VkRectLayerKHR*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pRectangles)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pRectangles, forUnmarshaling->rectangleCount * sizeof(const VkRectLayerKHR));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->rectangleCount; ++i)
+        {
+            unmarshal_VkRectLayerKHR(vkStream, (VkRectLayerKHR*)(forUnmarshaling->pRectangles + i));
+        }
+    }
+}
+
+void marshal_VkPresentRegionsKHR(
+    VulkanStream* vkStream,
+    const VkPresentRegionsKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_244 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
+    vkStream->putBe64(cgen_var_244);
+    if (forMarshaling->pRegions)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
+        {
+            marshal_VkPresentRegionKHR(vkStream, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i));
+        }
+    }
+}
+
+void unmarshal_VkPresentRegionsKHR(
+    VulkanStream* vkStream,
+    VkPresentRegionsKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pRegions = (const VkPresentRegionKHR*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pRegions)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pRegions, forUnmarshaling->swapchainCount * sizeof(const VkPresentRegionKHR));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i)
+        {
+            unmarshal_VkPresentRegionKHR(vkStream, (VkPresentRegionKHR*)(forUnmarshaling->pRegions + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+void marshal_VkAttachmentDescription2KHR(
+    VulkanStream* vkStream,
+    const VkAttachmentDescription2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
+    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
+    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
+    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
+    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+    vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
+    vkStream->write((VkImageLayout*)&forMarshaling->finalLayout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkAttachmentDescription2KHR(
+    VulkanStream* vkStream,
+    VkAttachmentDescription2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
+    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
+    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
+    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->finalLayout, sizeof(VkImageLayout));
+}
+
+void marshal_VkAttachmentReference2KHR(
+    VulkanStream* vkStream,
+    const VkAttachmentReference2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
+    vkStream->write((VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
+    vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+}
+
+void unmarshal_VkAttachmentReference2KHR(
+    VulkanStream* vkStream,
+    VkAttachmentReference2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->attachment, sizeof(uint32_t));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->layout, sizeof(VkImageLayout));
+    vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
+}
+
+void marshal_VkSubpassDescription2KHR(
+    VulkanStream* vkStream,
+    const VkSubpassDescription2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkSubpassDescriptionFlags*)&forMarshaling->flags, sizeof(VkSubpassDescriptionFlags));
+    vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
+    {
+        marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pInputAttachments + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
+    {
+        marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pColorAttachments + i));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_246 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
+    vkStream->putBe64(cgen_var_246);
+    if (forMarshaling->pResolveAttachments)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
+        {
+            marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pResolveAttachments + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_247 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
+    vkStream->putBe64(cgen_var_247);
+    if (forMarshaling->pDepthStencilAttachment)
+    {
+        marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pDepthStencilAttachment));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pPreserveAttachments, forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkSubpassDescription2KHR(
+    VulkanStream* vkStream,
+    VkSubpassDescription2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkSubpassDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkSubpassDescriptionFlags));
+    vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pInputAttachments, forUnmarshaling->inputAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i)
+    {
+        unmarshal_VkAttachmentReference2KHR(vkStream, (VkAttachmentReference2KHR*)(forUnmarshaling->pInputAttachments + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pColorAttachments, forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
+    {
+        unmarshal_VkAttachmentReference2KHR(vkStream, (VkAttachmentReference2KHR*)(forUnmarshaling->pColorAttachments + i));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pResolveAttachments = (const VkAttachmentReference2KHR*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pResolveAttachments)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pResolveAttachments, forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
+        {
+            unmarshal_VkAttachmentReference2KHR(vkStream, (VkAttachmentReference2KHR*)(forUnmarshaling->pResolveAttachments + i));
+        }
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pDepthStencilAttachment = (const VkAttachmentReference2KHR*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pDepthStencilAttachment)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pDepthStencilAttachment, sizeof(const VkAttachmentReference2KHR));
+        unmarshal_VkAttachmentReference2KHR(vkStream, (VkAttachmentReference2KHR*)(forUnmarshaling->pDepthStencilAttachment));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->preserveAttachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pPreserveAttachments, forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pPreserveAttachments, forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+}
+
+void marshal_VkSubpassDependency2KHR(
+    VulkanStream* vkStream,
+    const VkSubpassDependency2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
+    vkStream->write((VkPipelineStageFlags*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
+    vkStream->write((VkPipelineStageFlags*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+    vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
+    vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
+    vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+    vkStream->write((int32_t*)&forMarshaling->viewOffset, sizeof(int32_t));
+}
+
+void unmarshal_VkSubpassDependency2KHR(
+    VulkanStream* vkStream,
+    VkSubpassDependency2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->srcSubpass, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dstSubpass, sizeof(uint32_t));
+    vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
+    vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+    vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
+    vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
+    vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+    vkStream->read((int32_t*)&forUnmarshaling->viewOffset, sizeof(int32_t));
+}
+
+void marshal_VkRenderPassCreateInfo2KHR(
+    VulkanStream* vkStream,
+    const VkRenderPassCreateInfo2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkRenderPassCreateFlags*)&forMarshaling->flags, sizeof(VkRenderPassCreateFlags));
+    vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
+    {
+        marshal_VkAttachmentDescription2KHR(vkStream, (const VkAttachmentDescription2KHR*)(forMarshaling->pAttachments + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i)
+    {
+        marshal_VkSubpassDescription2KHR(vkStream, (const VkSubpassDescription2KHR*)(forMarshaling->pSubpasses + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i)
+    {
+        marshal_VkSubpassDependency2KHR(vkStream, (const VkSubpassDependency2KHR*)(forMarshaling->pDependencies + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->correlatedViewMaskCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pCorrelatedViewMasks, forMarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkRenderPassCreateInfo2KHR(
+    VulkanStream* vkStream,
+    VkRenderPassCreateInfo2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags, sizeof(VkRenderPassCreateFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount * sizeof(const VkAttachmentDescription2KHR));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
+    {
+        unmarshal_VkAttachmentDescription2KHR(vkStream, (VkAttachmentDescription2KHR*)(forUnmarshaling->pAttachments + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSubpasses, forUnmarshaling->subpassCount * sizeof(const VkSubpassDescription2KHR));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i)
+    {
+        unmarshal_VkSubpassDescription2KHR(vkStream, (VkSubpassDescription2KHR*)(forUnmarshaling->pSubpasses + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDependencies, forUnmarshaling->dependencyCount * sizeof(const VkSubpassDependency2KHR));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i)
+    {
+        unmarshal_VkSubpassDependency2KHR(vkStream, (VkSubpassDependency2KHR*)(forUnmarshaling->pDependencies + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->correlatedViewMaskCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pCorrelatedViewMasks, forUnmarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pCorrelatedViewMasks, forUnmarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
+}
+
+void marshal_VkSubpassBeginInfoKHR(
+    VulkanStream* vkStream,
+    const VkSubpassBeginInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkSubpassContents*)&forMarshaling->contents, sizeof(VkSubpassContents));
+}
+
+void unmarshal_VkSubpassBeginInfoKHR(
+    VulkanStream* vkStream,
+    VkSubpassBeginInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkSubpassContents*)&forUnmarshaling->contents, sizeof(VkSubpassContents));
+}
+
+void marshal_VkSubpassEndInfoKHR(
+    VulkanStream* vkStream,
+    const VkSubpassEndInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+}
+
+void unmarshal_VkSubpassEndInfoKHR(
+    VulkanStream* vkStream,
+    VkSubpassEndInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void marshal_VkSharedPresentSurfaceCapabilitiesKHR(
+    VulkanStream* vkStream,
+    const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkImageUsageFlags*)&forMarshaling->sharedPresentSupportedUsageFlags, sizeof(VkImageUsageFlags));
+}
+
+void unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
+    VulkanStream* vkStream,
+    VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->sharedPresentSupportedUsageFlags, sizeof(VkImageUsageFlags));
+}
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void marshal_VkImportFenceWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportFenceWin32HandleInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_250;
+    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_250, 1);
+    vkStream->write((uint64_t*)&cgen_var_250, 1 * 8);
+    vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
+    vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+    vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
+    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkImportFenceWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkImportFenceWin32HandleInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_251;
+    vkStream->read((uint64_t*)&cgen_var_251, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_251, (VkFence*)&forUnmarshaling->fence, 1);
+    vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
+    vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+    vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
+    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkExportFenceWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkExportFenceWin32HandleInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_252 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+    vkStream->putBe64(cgen_var_252);
+    if (forMarshaling->pAttributes)
+    {
+        vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+    vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
+    vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkExportFenceWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkExportFenceWin32HandleInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pAttributes)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+        vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+    vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
+    vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkFenceGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkFenceGetWin32HandleInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        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);
+    vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+void unmarshal_VkFenceGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkFenceGetWin32HandleInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, 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);
+    vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+void marshal_VkImportFenceFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportFenceFdInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_256;
+    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_256, 1);
+    vkStream->write((uint64_t*)&cgen_var_256, 1 * 8);
+    vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
+    vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+    vkStream->write((int*)&forMarshaling->fd, sizeof(int));
+}
+
+void unmarshal_VkImportFenceFdInfoKHR(
+    VulkanStream* vkStream,
+    VkImportFenceFdInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_257;
+    vkStream->read((uint64_t*)&cgen_var_257, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_257, (VkFence*)&forUnmarshaling->fence, 1);
+    vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
+    vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+    vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
+}
+
+void marshal_VkFenceGetFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkFenceGetFdInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        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);
+    vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+void unmarshal_VkFenceGetFdInfoKHR(
+    VulkanStream* vkStream,
+    VkFenceGetFdInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, 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);
+    vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void marshal_VkPhysicalDeviceSurfaceInfo2KHR(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_260;
+    vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_260, 1);
+    vkStream->write((uint64_t*)&cgen_var_260, 1 * 8);
+}
+
+void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, 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_VkSurfaceKHR(&cgen_var_261, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+}
+
+void marshal_VkSurfaceCapabilities2KHR(
+    VulkanStream* vkStream,
+    const VkSurfaceCapabilities2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkSurfaceCapabilitiesKHR(vkStream, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities));
+}
+
+void unmarshal_VkSurfaceCapabilities2KHR(
+    VulkanStream* vkStream,
+    VkSurfaceCapabilities2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkSurfaceCapabilitiesKHR(vkStream, (VkSurfaceCapabilitiesKHR*)(&forUnmarshaling->surfaceCapabilities));
+}
+
+void marshal_VkSurfaceFormat2KHR(
+    VulkanStream* vkStream,
+    const VkSurfaceFormat2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkSurfaceFormatKHR(vkStream, (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat));
+}
+
+void unmarshal_VkSurfaceFormat2KHR(
+    VulkanStream* vkStream,
+    VkSurfaceFormat2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkSurfaceFormatKHR(vkStream, (VkSurfaceFormatKHR*)(&forUnmarshaling->surfaceFormat));
+}
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void marshal_VkDisplayProperties2KHR(
+    VulkanStream* vkStream,
+    const VkDisplayProperties2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkDisplayPropertiesKHR(vkStream, (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties));
+}
+
+void unmarshal_VkDisplayProperties2KHR(
+    VulkanStream* vkStream,
+    VkDisplayProperties2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkDisplayPropertiesKHR(vkStream, (VkDisplayPropertiesKHR*)(&forUnmarshaling->displayProperties));
+}
+
+void marshal_VkDisplayPlaneProperties2KHR(
+    VulkanStream* vkStream,
+    const VkDisplayPlaneProperties2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkDisplayPlanePropertiesKHR(vkStream, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties));
+}
+
+void unmarshal_VkDisplayPlaneProperties2KHR(
+    VulkanStream* vkStream,
+    VkDisplayPlaneProperties2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkDisplayPlanePropertiesKHR(vkStream, (VkDisplayPlanePropertiesKHR*)(&forUnmarshaling->displayPlaneProperties));
+}
+
+void marshal_VkDisplayModeProperties2KHR(
+    VulkanStream* vkStream,
+    const VkDisplayModeProperties2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkDisplayModePropertiesKHR(vkStream, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties));
+}
+
+void unmarshal_VkDisplayModeProperties2KHR(
+    VulkanStream* vkStream,
+    VkDisplayModeProperties2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkDisplayModePropertiesKHR(vkStream, (VkDisplayModePropertiesKHR*)(&forUnmarshaling->displayModeProperties));
+}
+
+void marshal_VkDisplayPlaneInfo2KHR(
+    VulkanStream* vkStream,
+    const VkDisplayPlaneInfo2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_262;
+    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_262, 1);
+    vkStream->write((uint64_t*)&cgen_var_262, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkDisplayPlaneInfo2KHR(
+    VulkanStream* vkStream,
+    VkDisplayPlaneInfo2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, 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_VkDisplayModeKHR(&cgen_var_263, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
+}
+
+void marshal_VkDisplayPlaneCapabilities2KHR(
+    VulkanStream* vkStream,
+    const VkDisplayPlaneCapabilities2KHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkDisplayPlaneCapabilitiesKHR(vkStream, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities));
+}
+
+void unmarshal_VkDisplayPlaneCapabilities2KHR(
+    VulkanStream* vkStream,
+    VkDisplayPlaneCapabilities2KHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkDisplayPlaneCapabilitiesKHR(vkStream, (VkDisplayPlaneCapabilitiesKHR*)(&forUnmarshaling->capabilities));
+}
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+void marshal_VkImageFormatListCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkImageFormatListCreateInfoKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->viewFormatCount, sizeof(uint32_t));
+    vkStream->write((const VkFormat*)forMarshaling->pViewFormats, forMarshaling->viewFormatCount * sizeof(const VkFormat));
+}
+
+void unmarshal_VkImageFormatListCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkImageFormatListCreateInfoKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->viewFormatCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pViewFormats, forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
+    vkStream->read((VkFormat*)forUnmarshaling->pViewFormats, forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
+}
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+void marshal_VkPhysicalDevice8BitStorageFeaturesKHR(
+    VulkanStream* vkStream,
+    const VkPhysicalDevice8BitStorageFeaturesKHR* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->storagePushConstant8, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevice8BitStorageFeaturesKHR(
+    VulkanStream* vkStream,
+    VkPhysicalDevice8BitStorageFeaturesKHR* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant8, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void marshal_VkNativeBufferANDROID(
+    VulkanStream* vkStream,
+    const VkNativeBufferANDROID* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_264 = (uint64_t)(uintptr_t)forMarshaling->handle;
+    vkStream->putBe64(cgen_var_264);
+    if (forMarshaling->handle)
+    {
+        vkStream->write((const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
+    }
+    vkStream->write((int*)&forMarshaling->stride, sizeof(int));
+    vkStream->write((int*)&forMarshaling->format, sizeof(int));
+    vkStream->write((int*)&forMarshaling->usage, sizeof(int));
+    vkStream->write((uint64_t*)&forMarshaling->consumer, sizeof(uint64_t));
+    vkStream->write((uint64_t*)&forMarshaling->producer, sizeof(uint64_t));
+}
+
+void unmarshal_VkNativeBufferANDROID(
+    VulkanStream* vkStream,
+    VkNativeBufferANDROID* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->handle = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->handle)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->handle, sizeof(const uint32_t));
+        vkStream->read((uint32_t*)forUnmarshaling->handle, sizeof(const uint32_t));
+    }
+    vkStream->read((int*)&forUnmarshaling->stride, sizeof(int));
+    vkStream->read((int*)&forUnmarshaling->format, sizeof(int));
+    vkStream->read((int*)&forUnmarshaling->usage, sizeof(int));
+    vkStream->read((uint64_t*)&forUnmarshaling->consumer, sizeof(uint64_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->producer, sizeof(uint64_t));
+}
+
+#endif
+#ifdef VK_EXT_debug_report
+void marshal_VkDebugReportCallbackCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugReportCallbackCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDebugReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugReportFlagsEXT));
+    uint64_t cgen_var_266 = (uint64_t)forMarshaling->pfnCallback;
+    vkStream->putBe64(cgen_var_266);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_267 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+    vkStream->putBe64(cgen_var_267);
+    if (forMarshaling->pUserData)
+    {
+        vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
+    }
+}
+
+void unmarshal_VkDebugReportCallbackCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugReportCallbackCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDebugReportFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugReportFlagsEXT));
+    forUnmarshaling->pfnCallback = (PFN_vkDebugReportCallbackEXT)vkStream->getBe64();
+    // WARNING PTR CHECK
+    forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pUserData)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
+        vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+    VulkanStream* vkStream,
+    const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkRasterizationOrderAMD*)&forMarshaling->rasterizationOrder, sizeof(VkRasterizationOrderAMD));
+}
+
+void unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+    VulkanStream* vkStream,
+    VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkRasterizationOrderAMD*)&forUnmarshaling->rasterizationOrder, sizeof(VkRasterizationOrderAMD));
+}
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void marshal_VkDebugMarkerObjectNameInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugMarkerObjectNameInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+    vkStream->write((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
+    vkStream->putString(forMarshaling->pObjectName);
+}
+
+void unmarshal_VkDebugMarkerObjectNameInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugMarkerObjectNameInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDebugReportObjectTypeEXT*)&forUnmarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+    vkStream->read((uint64_t*)&forUnmarshaling->object, sizeof(uint64_t));
+    vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
+}
+
+void marshal_VkDebugMarkerObjectTagInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugMarkerObjectTagInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+    vkStream->write((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
+    vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
+    uint64_t cgen_var_270 = (uint64_t)forMarshaling->tagSize;
+    vkStream->putBe64(cgen_var_270);
+    vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkDebugMarkerObjectTagInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugMarkerObjectTagInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDebugReportObjectTypeEXT*)&forUnmarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+    vkStream->read((uint64_t*)&forUnmarshaling->object, sizeof(uint64_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->tagName, sizeof(uint64_t));
+    forUnmarshaling->tagSize = (size_t)vkStream->getBe64();
+    vkStream->alloc((void**)&forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
+    vkStream->read((void*)forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
+}
+
+void marshal_VkDebugMarkerMarkerInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugMarkerMarkerInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->putString(forMarshaling->pMarkerName);
+    vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
+}
+
+void unmarshal_VkDebugMarkerMarkerInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugMarkerMarkerInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->loadStringInPlace((char**)&forUnmarshaling->pMarkerName);
+    vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
+}
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void marshal_VkDedicatedAllocationImageCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkDedicatedAllocationImageCreateInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
+}
+
+void unmarshal_VkDedicatedAllocationImageCreateInfoNV(
+    VulkanStream* vkStream,
+    VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocation, sizeof(VkBool32));
+}
+
+void marshal_VkDedicatedAllocationBufferCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
+}
+
+void unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
+    VulkanStream* vkStream,
+    VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocation, sizeof(VkBool32));
+}
+
+void marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+    VulkanStream* vkStream,
+    const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_272;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_272, 1);
+    vkStream->write((uint64_t*)&cgen_var_272, 1 * 8);
+    uint64_t cgen_var_273;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_273, 1);
+    vkStream->write((uint64_t*)&cgen_var_273, 1 * 8);
+}
+
+void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+    VulkanStream* vkStream,
+    VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_274;
+    vkStream->read((uint64_t*)&cgen_var_274, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_274, (VkImage*)&forUnmarshaling->image, 1);
+    uint64_t cgen_var_275;
+    vkStream->read((uint64_t*)&cgen_var_275, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_275, (VkBuffer*)&forUnmarshaling->buffer, 1);
+}
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void marshal_VkTextureLODGatherFormatPropertiesAMD(
+    VulkanStream* vkStream,
+    const VkTextureLODGatherFormatPropertiesAMD* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
+}
+
+void unmarshal_VkTextureLODGatherFormatPropertiesAMD(
+    VulkanStream* vkStream,
+    VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_AMD_shader_info
+void marshal_VkShaderResourceUsageAMD(
+    VulkanStream* vkStream,
+    const VkShaderResourceUsageAMD* forMarshaling)
+{
+    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_276 = (uint64_t)forMarshaling->ldsUsageSizeInBytes;
+    vkStream->putBe64(cgen_var_276);
+    uint64_t cgen_var_277 = (uint64_t)forMarshaling->scratchMemUsageInBytes;
+    vkStream->putBe64(cgen_var_277);
+}
+
+void unmarshal_VkShaderResourceUsageAMD(
+    VulkanStream* vkStream,
+    VkShaderResourceUsageAMD* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->numUsedVgprs, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->numUsedSgprs, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->ldsSizePerLocalWorkGroup, sizeof(uint32_t));
+    forUnmarshaling->ldsUsageSizeInBytes = (size_t)vkStream->getBe64();
+    forUnmarshaling->scratchMemUsageInBytes = (size_t)vkStream->getBe64();
+}
+
+void marshal_VkShaderStatisticsInfoAMD(
+    VulkanStream* vkStream,
+    const VkShaderStatisticsInfoAMD* forMarshaling)
+{
+    vkStream->write((VkShaderStageFlags*)&forMarshaling->shaderStageMask, sizeof(VkShaderStageFlags));
+    marshal_VkShaderResourceUsageAMD(vkStream, (VkShaderResourceUsageAMD*)(&forMarshaling->resourceUsage));
+    vkStream->write((uint32_t*)&forMarshaling->numPhysicalVgprs, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->numPhysicalSgprs, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->numAvailableVgprs, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->numAvailableSgprs, sizeof(uint32_t));
+    vkStream->write((uint32_t*)forMarshaling->computeWorkGroupSize, 3 * sizeof(uint32_t));
+}
+
+void unmarshal_VkShaderStatisticsInfoAMD(
+    VulkanStream* vkStream,
+    VkShaderStatisticsInfoAMD* forUnmarshaling)
+{
+    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->shaderStageMask, sizeof(VkShaderStageFlags));
+    unmarshal_VkShaderResourceUsageAMD(vkStream, (VkShaderResourceUsageAMD*)(&forUnmarshaling->resourceUsage));
+    vkStream->read((uint32_t*)&forUnmarshaling->numPhysicalVgprs, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->numPhysicalSgprs, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->numAvailableVgprs, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->numAvailableSgprs, sizeof(uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->computeWorkGroupSize, 3 * sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void marshal_VkExternalImageFormatPropertiesNV(
+    VulkanStream* vkStream,
+    const VkExternalImageFormatPropertiesNV* forMarshaling)
+{
+    marshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
+    vkStream->write((VkExternalMemoryFeatureFlagsNV*)&forMarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlagsNV));
+    vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+    vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+void unmarshal_VkExternalImageFormatPropertiesNV(
+    VulkanStream* vkStream,
+    VkExternalImageFormatPropertiesNV* forUnmarshaling)
+{
+    unmarshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
+    vkStream->read((VkExternalMemoryFeatureFlagsNV*)&forUnmarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlagsNV));
+    vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+    vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+#endif
+#ifdef VK_NV_external_memory
+void marshal_VkExternalMemoryImageCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkExternalMemoryImageCreateInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+void unmarshal_VkExternalMemoryImageCreateInfoNV(
+    VulkanStream* vkStream,
+    VkExternalMemoryImageCreateInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+void marshal_VkExportMemoryAllocateInfoNV(
+    VulkanStream* vkStream,
+    const VkExportMemoryAllocateInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+void unmarshal_VkExportMemoryAllocateInfoNV(
+    VulkanStream* vkStream,
+    VkExportMemoryAllocateInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void marshal_VkImportMemoryWin32HandleInfoNV(
+    VulkanStream* vkStream,
+    const VkImportMemoryWin32HandleInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+    vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
+}
+
+void unmarshal_VkImportMemoryWin32HandleInfoNV(
+    VulkanStream* vkStream,
+    VkImportMemoryWin32HandleInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+    vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
+}
+
+void marshal_VkExportMemoryWin32HandleInfoNV(
+    VulkanStream* vkStream,
+    const VkExportMemoryWin32HandleInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_280 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+    vkStream->putBe64(cgen_var_280);
+    if (forMarshaling->pAttributes)
+    {
+        vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+    vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
+}
+
+void unmarshal_VkExportMemoryWin32HandleInfoNV(
+    VulkanStream* vkStream,
+    VkExportMemoryWin32HandleInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pAttributes)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+        vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+    }
+    vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
+}
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+    VulkanStream* vkStream,
+    const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
+    if (forMarshaling->acquireCount)
+    {
+        uint64_t* cgen_var_282;
+        vkStream->alloc((void**)&cgen_var_282, forMarshaling->acquireCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_282, forMarshaling->acquireCount);
+        vkStream->write((uint64_t*)cgen_var_282, 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_283;
+        vkStream->alloc((void**)&cgen_var_283, forMarshaling->releaseCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_283, forMarshaling->releaseCount);
+        vkStream->write((uint64_t*)cgen_var_283, forMarshaling->releaseCount * 8);
+    }
+    vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
+}
+
+void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+    VulkanStream* vkStream,
+    VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount * sizeof(const VkDeviceMemory));
+    if (forUnmarshaling->acquireCount)
+    {
+        uint64_t* cgen_var_284;
+        vkStream->alloc((void**)&cgen_var_284, forUnmarshaling->acquireCount * 8);
+        vkStream->read((uint64_t*)cgen_var_284, forUnmarshaling->acquireCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_284, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
+    vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
+    vkStream->alloc((void**)&forUnmarshaling->pAcquireTimeoutMilliseconds, forUnmarshaling->acquireCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeoutMilliseconds, forUnmarshaling->acquireCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount * sizeof(const VkDeviceMemory));
+    if (forUnmarshaling->releaseCount)
+    {
+        uint64_t* cgen_var_285;
+        vkStream->alloc((void**)&cgen_var_285, forUnmarshaling->releaseCount * 8);
+        vkStream->read((uint64_t*)cgen_var_285, forUnmarshaling->releaseCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_285, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
+    vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
+}
+
+#endif
+#ifdef VK_EXT_validation_flags
+void marshal_VkValidationFlagsEXT(
+    VulkanStream* vkStream,
+    const VkValidationFlagsEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->disabledValidationCheckCount, sizeof(uint32_t));
+    vkStream->write((const VkValidationCheckEXT*)forMarshaling->pDisabledValidationChecks, forMarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+}
+
+void unmarshal_VkValidationFlagsEXT(
+    VulkanStream* vkStream,
+    VkValidationFlagsEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->disabledValidationCheckCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDisabledValidationChecks, forUnmarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+    vkStream->read((VkValidationCheckEXT*)forUnmarshaling->pDisabledValidationChecks, forUnmarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+}
+
+#endif
+#ifdef VK_NN_vi_surface
+void marshal_VkViSurfaceCreateInfoNN(
+    VulkanStream* vkStream,
+    const VkViSurfaceCreateInfoNN* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkViSurfaceCreateFlagsNN*)&forMarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_286 = (uint64_t)(uintptr_t)forMarshaling->window;
+    vkStream->putBe64(cgen_var_286);
+    if (forMarshaling->window)
+    {
+        vkStream->write((void*)forMarshaling->window, sizeof(uint8_t));
+    }
+}
+
+void unmarshal_VkViSurfaceCreateInfoNN(
+    VulkanStream* vkStream,
+    VkViSurfaceCreateInfoNN* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkViSurfaceCreateFlagsNN*)&forUnmarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
+    // WARNING PTR CHECK
+    forUnmarshaling->window = (void*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->window)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->window, sizeof(uint8_t));
+        vkStream->read((void*)forUnmarshaling->window, sizeof(uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void marshal_VkConditionalRenderingBeginInfoEXT(
+    VulkanStream* vkStream,
+    const VkConditionalRenderingBeginInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_288;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_288, 1);
+    vkStream->write((uint64_t*)&cgen_var_288, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->write((VkConditionalRenderingFlagsEXT*)&forMarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
+}
+
+void unmarshal_VkConditionalRenderingBeginInfoEXT(
+    VulkanStream* vkStream,
+    VkConditionalRenderingBeginInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    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);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->read((VkConditionalRenderingFlagsEXT*)&forUnmarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
+}
+
+void marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->conditionalRendering, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->inheritedConditionalRendering, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->conditionalRendering, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->inheritedConditionalRendering, sizeof(VkBool32));
+}
+
+void marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+    VulkanStream* vkStream,
+    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->conditionalRenderingEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+    VulkanStream* vkStream,
+    VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->conditionalRenderingEnable, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void marshal_VkDeviceGeneratedCommandsFeaturesNVX(
+    VulkanStream* vkStream,
+    const VkDeviceGeneratedCommandsFeaturesNVX* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->computeBindingPointSupport, sizeof(VkBool32));
+}
+
+void unmarshal_VkDeviceGeneratedCommandsFeaturesNVX(
+    VulkanStream* vkStream,
+    VkDeviceGeneratedCommandsFeaturesNVX* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->computeBindingPointSupport, sizeof(VkBool32));
+}
+
+void marshal_VkDeviceGeneratedCommandsLimitsNVX(
+    VulkanStream* vkStream,
+    const VkDeviceGeneratedCommandsLimitsNVX* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->maxIndirectCommandsLayoutTokenCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxObjectEntryCounts, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minSequenceCountBufferOffsetAlignment, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minSequenceIndexBufferOffsetAlignment, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minCommandsTokenBufferOffsetAlignment, sizeof(uint32_t));
+}
+
+void unmarshal_VkDeviceGeneratedCommandsLimitsNVX(
+    VulkanStream* vkStream,
+    VkDeviceGeneratedCommandsLimitsNVX* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectCommandsLayoutTokenCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxObjectEntryCounts, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minSequenceCountBufferOffsetAlignment, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minSequenceIndexBufferOffsetAlignment, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minCommandsTokenBufferOffsetAlignment, sizeof(uint32_t));
+}
+
+void marshal_VkIndirectCommandsTokenNVX(
+    VulkanStream* vkStream,
+    const VkIndirectCommandsTokenNVX* forMarshaling)
+{
+    vkStream->write((VkIndirectCommandsTokenTypeNVX*)&forMarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
+    uint64_t cgen_var_290;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_290, 1);
+    vkStream->write((uint64_t*)&cgen_var_290, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkIndirectCommandsTokenNVX(
+    VulkanStream* vkStream,
+    VkIndirectCommandsTokenNVX* forUnmarshaling)
+{
+    vkStream->read((VkIndirectCommandsTokenTypeNVX*)&forUnmarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
+    uint64_t cgen_var_291;
+    vkStream->read((uint64_t*)&cgen_var_291, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_291, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+}
+
+void marshal_VkIndirectCommandsLayoutTokenNVX(
+    VulkanStream* vkStream,
+    const VkIndirectCommandsLayoutTokenNVX* forMarshaling)
+{
+    vkStream->write((VkIndirectCommandsTokenTypeNVX*)&forMarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
+    vkStream->write((uint32_t*)&forMarshaling->bindingUnit, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->dynamicCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->divisor, sizeof(uint32_t));
+}
+
+void unmarshal_VkIndirectCommandsLayoutTokenNVX(
+    VulkanStream* vkStream,
+    VkIndirectCommandsLayoutTokenNVX* forUnmarshaling)
+{
+    vkStream->read((VkIndirectCommandsTokenTypeNVX*)&forUnmarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
+    vkStream->read((uint32_t*)&forUnmarshaling->bindingUnit, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dynamicCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->divisor, sizeof(uint32_t));
+}
+
+void marshal_VkIndirectCommandsLayoutCreateInfoNVX(
+    VulkanStream* vkStream,
+    const VkIndirectCommandsLayoutCreateInfoNVX* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    vkStream->write((VkIndirectCommandsLayoutUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkIndirectCommandsLayoutUsageFlagsNVX));
+    vkStream->write((uint32_t*)&forMarshaling->tokenCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->tokenCount; ++i)
+    {
+        marshal_VkIndirectCommandsLayoutTokenNVX(vkStream, (const VkIndirectCommandsLayoutTokenNVX*)(forMarshaling->pTokens + i));
+    }
+}
+
+void unmarshal_VkIndirectCommandsLayoutCreateInfoNVX(
+    VulkanStream* vkStream,
+    VkIndirectCommandsLayoutCreateInfoNVX* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+    vkStream->read((VkIndirectCommandsLayoutUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkIndirectCommandsLayoutUsageFlagsNVX));
+    vkStream->read((uint32_t*)&forUnmarshaling->tokenCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pTokens, forUnmarshaling->tokenCount * sizeof(const VkIndirectCommandsLayoutTokenNVX));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->tokenCount; ++i)
+    {
+        unmarshal_VkIndirectCommandsLayoutTokenNVX(vkStream, (VkIndirectCommandsLayoutTokenNVX*)(forUnmarshaling->pTokens + i));
+    }
+}
+
+void marshal_VkCmdProcessCommandsInfoNVX(
+    VulkanStream* vkStream,
+    const VkCmdProcessCommandsInfoNVX* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_292;
+    vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_292, 1);
+    vkStream->write((uint64_t*)&cgen_var_292, 1 * 8);
+    uint64_t cgen_var_293;
+    vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_293, 1);
+    vkStream->write((uint64_t*)&cgen_var_293, 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_294;
+    vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->targetCommandBuffer, &cgen_var_294, 1);
+    vkStream->write((uint64_t*)&cgen_var_294, 1 * 8);
+    uint64_t cgen_var_295;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesCountBuffer, &cgen_var_295, 1);
+    vkStream->write((uint64_t*)&cgen_var_295, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
+    uint64_t cgen_var_296;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesIndexBuffer, &cgen_var_296, 1);
+    vkStream->write((uint64_t*)&cgen_var_296, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkCmdProcessCommandsInfoNVX(
+    VulkanStream* vkStream,
+    VkCmdProcessCommandsInfoNVX* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_297;
+    vkStream->read((uint64_t*)&cgen_var_297, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_297, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
+    uint64_t cgen_var_298;
+    vkStream->read((uint64_t*)&cgen_var_298, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_298, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->indirectCommandsTokenCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pIndirectCommandsTokens, forUnmarshaling->indirectCommandsTokenCount * sizeof(const VkIndirectCommandsTokenNVX));
+    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_299;
+    vkStream->read((uint64_t*)&cgen_var_299, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(&cgen_var_299, (VkCommandBuffer*)&forUnmarshaling->targetCommandBuffer, 1);
+    uint64_t cgen_var_300;
+    vkStream->read((uint64_t*)&cgen_var_300, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_300, (VkBuffer*)&forUnmarshaling->sequencesCountBuffer, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
+    uint64_t cgen_var_301;
+    vkStream->read((uint64_t*)&cgen_var_301, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_301, (VkBuffer*)&forUnmarshaling->sequencesIndexBuffer, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
+}
+
+void marshal_VkCmdReserveSpaceForCommandsInfoNVX(
+    VulkanStream* vkStream,
+    const VkCmdReserveSpaceForCommandsInfoNVX* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_302;
+    vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_302, 1);
+    vkStream->write((uint64_t*)&cgen_var_302, 1 * 8);
+    uint64_t cgen_var_303;
+    vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_303, 1);
+    vkStream->write((uint64_t*)&cgen_var_303, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->maxSequencesCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkCmdReserveSpaceForCommandsInfoNVX(
+    VulkanStream* vkStream,
+    VkCmdReserveSpaceForCommandsInfoNVX* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_304;
+    vkStream->read((uint64_t*)&cgen_var_304, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_304, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
+    uint64_t cgen_var_305;
+    vkStream->read((uint64_t*)&cgen_var_305, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_305, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->maxSequencesCount, sizeof(uint32_t));
+}
+
+void marshal_VkObjectTableCreateInfoNVX(
+    VulkanStream* vkStream,
+    const VkObjectTableCreateInfoNVX* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
+    vkStream->write((const VkObjectEntryTypeNVX*)forMarshaling->pObjectEntryTypes, forMarshaling->objectCount * sizeof(const VkObjectEntryTypeNVX));
+    vkStream->write((const uint32_t*)forMarshaling->pObjectEntryCounts, forMarshaling->objectCount * sizeof(const uint32_t));
+    vkStream->write((const VkObjectEntryUsageFlagsNVX*)forMarshaling->pObjectEntryUsageFlags, forMarshaling->objectCount * sizeof(const VkObjectEntryUsageFlagsNVX));
+    vkStream->write((uint32_t*)&forMarshaling->maxUniformBuffersPerDescriptor, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStorageBuffersPerDescriptor, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStorageImagesPerDescriptor, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxSampledImagesPerDescriptor, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPipelineLayouts, sizeof(uint32_t));
+}
+
+void unmarshal_VkObjectTableCreateInfoNVX(
+    VulkanStream* vkStream,
+    VkObjectTableCreateInfoNVX* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->objectCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pObjectEntryTypes, forUnmarshaling->objectCount * sizeof(const VkObjectEntryTypeNVX));
+    vkStream->read((VkObjectEntryTypeNVX*)forUnmarshaling->pObjectEntryTypes, forUnmarshaling->objectCount * sizeof(const VkObjectEntryTypeNVX));
+    vkStream->alloc((void**)&forUnmarshaling->pObjectEntryCounts, forUnmarshaling->objectCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pObjectEntryCounts, forUnmarshaling->objectCount * sizeof(const uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pObjectEntryUsageFlags, forUnmarshaling->objectCount * sizeof(const VkObjectEntryUsageFlagsNVX));
+    vkStream->read((VkObjectEntryUsageFlagsNVX*)forUnmarshaling->pObjectEntryUsageFlags, forUnmarshaling->objectCount * sizeof(const VkObjectEntryUsageFlagsNVX));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxUniformBuffersPerDescriptor, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStorageBuffersPerDescriptor, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStorageImagesPerDescriptor, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxSampledImagesPerDescriptor, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineLayouts, sizeof(uint32_t));
+}
+
+void marshal_VkObjectTableEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTableEntryNVX* forMarshaling)
+{
+    vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+}
+
+void unmarshal_VkObjectTableEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTableEntryNVX* forUnmarshaling)
+{
+    vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+}
+
+void marshal_VkObjectTablePipelineEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTablePipelineEntryNVX* forMarshaling)
+{
+    vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+    uint64_t cgen_var_306;
+    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_306, 1);
+    vkStream->write((uint64_t*)&cgen_var_306, 1 * 8);
+}
+
+void unmarshal_VkObjectTablePipelineEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTablePipelineEntryNVX* forUnmarshaling)
+{
+    vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+    uint64_t cgen_var_307;
+    vkStream->read((uint64_t*)&cgen_var_307, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_307, (VkPipeline*)&forUnmarshaling->pipeline, 1);
+}
+
+void marshal_VkObjectTableDescriptorSetEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTableDescriptorSetEntryNVX* forMarshaling)
+{
+    vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+    uint64_t cgen_var_308;
+    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_308, 1);
+    vkStream->write((uint64_t*)&cgen_var_308, 1 * 8);
+    uint64_t cgen_var_309;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->descriptorSet, &cgen_var_309, 1);
+    vkStream->write((uint64_t*)&cgen_var_309, 1 * 8);
+}
+
+void unmarshal_VkObjectTableDescriptorSetEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTableDescriptorSetEntryNVX* forUnmarshaling)
+{
+    vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+    uint64_t cgen_var_310;
+    vkStream->read((uint64_t*)&cgen_var_310, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_310, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+    uint64_t cgen_var_311;
+    vkStream->read((uint64_t*)&cgen_var_311, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_311, (VkDescriptorSet*)&forUnmarshaling->descriptorSet, 1);
+}
+
+void marshal_VkObjectTableVertexBufferEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTableVertexBufferEntryNVX* forMarshaling)
+{
+    vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+    uint64_t cgen_var_312;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_312, 1);
+    vkStream->write((uint64_t*)&cgen_var_312, 1 * 8);
+}
+
+void unmarshal_VkObjectTableVertexBufferEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTableVertexBufferEntryNVX* forUnmarshaling)
+{
+    vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+    uint64_t cgen_var_313;
+    vkStream->read((uint64_t*)&cgen_var_313, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_313, (VkBuffer*)&forUnmarshaling->buffer, 1);
+}
+
+void marshal_VkObjectTableIndexBufferEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTableIndexBufferEntryNVX* forMarshaling)
+{
+    vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+    uint64_t cgen_var_314;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_314, 1);
+    vkStream->write((uint64_t*)&cgen_var_314, 1 * 8);
+    vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
+}
+
+void unmarshal_VkObjectTableIndexBufferEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTableIndexBufferEntryNVX* forUnmarshaling)
+{
+    vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+    uint64_t cgen_var_315;
+    vkStream->read((uint64_t*)&cgen_var_315, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_315, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
+}
+
+void marshal_VkObjectTablePushConstantEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTablePushConstantEntryNVX* forMarshaling)
+{
+    vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+    vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+    uint64_t cgen_var_316;
+    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_316, 1);
+    vkStream->write((uint64_t*)&cgen_var_316, 1 * 8);
+    vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+}
+
+void unmarshal_VkObjectTablePushConstantEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTablePushConstantEntryNVX* forUnmarshaling)
+{
+    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_VkPipelineLayout(&cgen_var_317, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
+}
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void marshal_VkViewportWScalingNV(
+    VulkanStream* vkStream,
+    const VkViewportWScalingNV* forMarshaling)
+{
+    vkStream->write((float*)&forMarshaling->xcoeff, sizeof(float));
+    vkStream->write((float*)&forMarshaling->ycoeff, sizeof(float));
+}
+
+void unmarshal_VkViewportWScalingNV(
+    VulkanStream* vkStream,
+    VkViewportWScalingNV* forUnmarshaling)
+{
+    vkStream->read((float*)&forUnmarshaling->xcoeff, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->ycoeff, sizeof(float));
+}
+
+void marshal_VkPipelineViewportWScalingStateCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->viewportWScalingEnable, sizeof(VkBool32));
+    vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_318 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
+    vkStream->putBe64(cgen_var_318);
+    if (forMarshaling->pViewportWScalings)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
+        {
+            marshal_VkViewportWScalingNV(vkStream, (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i));
+        }
+    }
+}
+
+void unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
+    VulkanStream* vkStream,
+    VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->viewportWScalingEnable, sizeof(VkBool32));
+    vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pViewportWScalings = (const VkViewportWScalingNV*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pViewportWScalings)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pViewportWScalings, forUnmarshaling->viewportCount * sizeof(const VkViewportWScalingNV));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
+        {
+            unmarshal_VkViewportWScalingNV(vkStream, (VkViewportWScalingNV*)(forUnmarshaling->pViewportWScalings + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+void marshal_VkSurfaceCapabilities2EXT(
+    VulkanStream* vkStream,
+    const VkSurfaceCapabilities2EXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxImageCount, sizeof(uint32_t));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->currentExtent));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minImageExtent));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxImageExtent));
+    vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
+    vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+    vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+    vkStream->write((VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
+    vkStream->write((VkImageUsageFlags*)&forMarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+    vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->supportedSurfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+}
+
+void unmarshal_VkSurfaceCapabilities2EXT(
+    VulkanStream* vkStream,
+    VkSurfaceCapabilities2EXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxImageCount, sizeof(uint32_t));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->currentExtent));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->minImageExtent));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxImageExtent));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
+    vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+    vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+    vkStream->read((VkCompositeAlphaFlagsKHR*)&forUnmarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
+    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+    vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->supportedSurfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+}
+
+#endif
+#ifdef VK_EXT_display_control
+void marshal_VkDisplayPowerInfoEXT(
+    VulkanStream* vkStream,
+    const VkDisplayPowerInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDisplayPowerStateEXT*)&forMarshaling->powerState, sizeof(VkDisplayPowerStateEXT));
+}
+
+void unmarshal_VkDisplayPowerInfoEXT(
+    VulkanStream* vkStream,
+    VkDisplayPowerInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDisplayPowerStateEXT*)&forUnmarshaling->powerState, sizeof(VkDisplayPowerStateEXT));
+}
+
+void marshal_VkDeviceEventInfoEXT(
+    VulkanStream* vkStream,
+    const VkDeviceEventInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDeviceEventTypeEXT*)&forMarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
+}
+
+void unmarshal_VkDeviceEventInfoEXT(
+    VulkanStream* vkStream,
+    VkDeviceEventInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceEventTypeEXT*)&forUnmarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
+}
+
+void marshal_VkDisplayEventInfoEXT(
+    VulkanStream* vkStream,
+    const VkDisplayEventInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDisplayEventTypeEXT*)&forMarshaling->displayEvent, sizeof(VkDisplayEventTypeEXT));
+}
+
+void unmarshal_VkDisplayEventInfoEXT(
+    VulkanStream* vkStream,
+    VkDisplayEventInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDisplayEventTypeEXT*)&forUnmarshaling->displayEvent, sizeof(VkDisplayEventTypeEXT));
+}
+
+void marshal_VkSwapchainCounterCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkSwapchainCounterCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->surfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+}
+
+void unmarshal_VkSwapchainCounterCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkSwapchainCounterCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->surfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+}
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+void marshal_VkRefreshCycleDurationGOOGLE(
+    VulkanStream* vkStream,
+    const VkRefreshCycleDurationGOOGLE* forMarshaling)
+{
+    vkStream->write((uint64_t*)&forMarshaling->refreshDuration, sizeof(uint64_t));
+}
+
+void unmarshal_VkRefreshCycleDurationGOOGLE(
+    VulkanStream* vkStream,
+    VkRefreshCycleDurationGOOGLE* forUnmarshaling)
+{
+    vkStream->read((uint64_t*)&forUnmarshaling->refreshDuration, sizeof(uint64_t));
+}
+
+void marshal_VkPastPresentationTimingGOOGLE(
+    VulkanStream* vkStream,
+    const VkPastPresentationTimingGOOGLE* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
+    vkStream->write((uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
+    vkStream->write((uint64_t*)&forMarshaling->actualPresentTime, sizeof(uint64_t));
+    vkStream->write((uint64_t*)&forMarshaling->earliestPresentTime, sizeof(uint64_t));
+    vkStream->write((uint64_t*)&forMarshaling->presentMargin, sizeof(uint64_t));
+}
+
+void unmarshal_VkPastPresentationTimingGOOGLE(
+    VulkanStream* vkStream,
+    VkPastPresentationTimingGOOGLE* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->presentID, sizeof(uint32_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->desiredPresentTime, sizeof(uint64_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->actualPresentTime, sizeof(uint64_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->earliestPresentTime, sizeof(uint64_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->presentMargin, sizeof(uint64_t));
+}
+
+void marshal_VkPresentTimeGOOGLE(
+    VulkanStream* vkStream,
+    const VkPresentTimeGOOGLE* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
+    vkStream->write((uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
+}
+
+void unmarshal_VkPresentTimeGOOGLE(
+    VulkanStream* vkStream,
+    VkPresentTimeGOOGLE* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->presentID, sizeof(uint32_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->desiredPresentTime, sizeof(uint64_t));
+}
+
+void marshal_VkPresentTimesInfoGOOGLE(
+    VulkanStream* vkStream,
+    const VkPresentTimesInfoGOOGLE* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_320 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
+    vkStream->putBe64(cgen_var_320);
+    if (forMarshaling->pTimes)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
+        {
+            marshal_VkPresentTimeGOOGLE(vkStream, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i));
+        }
+    }
+}
+
+void unmarshal_VkPresentTimesInfoGOOGLE(
+    VulkanStream* vkStream,
+    VkPresentTimesInfoGOOGLE* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pTimes = (const VkPresentTimeGOOGLE*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pTimes)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pTimes, forUnmarshaling->swapchainCount * sizeof(const VkPresentTimeGOOGLE));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i)
+        {
+            unmarshal_VkPresentTimeGOOGLE(vkStream, (VkPresentTimeGOOGLE*)(forUnmarshaling->pTimes + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->perViewPositionAllComponents, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->perViewPositionAllComponents, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void marshal_VkViewportSwizzleNV(
+    VulkanStream* vkStream,
+    const VkViewportSwizzleNV* forMarshaling)
+{
+    vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->x, sizeof(VkViewportCoordinateSwizzleNV));
+    vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->y, sizeof(VkViewportCoordinateSwizzleNV));
+    vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->z, sizeof(VkViewportCoordinateSwizzleNV));
+    vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->w, sizeof(VkViewportCoordinateSwizzleNV));
+}
+
+void unmarshal_VkViewportSwizzleNV(
+    VulkanStream* vkStream,
+    VkViewportSwizzleNV* forUnmarshaling)
+{
+    vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->x, sizeof(VkViewportCoordinateSwizzleNV));
+    vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->y, sizeof(VkViewportCoordinateSwizzleNV));
+    vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->z, sizeof(VkViewportCoordinateSwizzleNV));
+    vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->w, sizeof(VkViewportCoordinateSwizzleNV));
+}
+
+void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
+    vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_322 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
+    vkStream->putBe64(cgen_var_322);
+    if (forMarshaling->pViewportSwizzles)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
+        {
+            marshal_VkViewportSwizzleNV(vkStream, (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i));
+        }
+    }
+}
+
+void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+    VulkanStream* vkStream,
+    VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forUnmarshaling->flags, sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
+    vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pViewportSwizzles = (const VkViewportSwizzleNV*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pViewportSwizzles)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pViewportSwizzles, forUnmarshaling->viewportCount * sizeof(const VkViewportSwizzleNV));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
+        {
+            unmarshal_VkViewportSwizzleNV(vkStream, (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->maxDiscardRectangles, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDiscardRectangles, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
+    vkStream->write((VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode, sizeof(VkDiscardRectangleModeEXT));
+    vkStream->write((uint32_t*)&forMarshaling->discardRectangleCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_324 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
+    vkStream->putBe64(cgen_var_324);
+    if (forMarshaling->pDiscardRectangles)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i)
+        {
+            marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pDiscardRectangles + i));
+        }
+    }
+}
+
+void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
+    vkStream->read((VkDiscardRectangleModeEXT*)&forUnmarshaling->discardRectangleMode, sizeof(VkDiscardRectangleModeEXT));
+    vkStream->read((uint32_t*)&forUnmarshaling->discardRectangleCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pDiscardRectangles = (const VkRect2D*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pDiscardRectangles)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pDiscardRectangles, forUnmarshaling->discardRectangleCount * sizeof(const VkRect2D));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->discardRectangleCount; ++i)
+        {
+            unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pDiscardRectangles + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((float*)&forMarshaling->primitiveOverestimationSize, sizeof(float));
+    vkStream->write((float*)&forMarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
+    vkStream->write((float*)&forMarshaling->extraPrimitiveOverestimationSizeGranularity, sizeof(float));
+    vkStream->write((VkBool32*)&forMarshaling->primitiveUnderestimation, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->conservativePointAndLineRasterization, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->degenerateTrianglesRasterized, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->degenerateLinesRasterized, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->fullyCoveredFragmentShaderInputVariable, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->conservativeRasterizationPostDepthCoverage, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((float*)&forUnmarshaling->primitiveOverestimationSize, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->extraPrimitiveOverestimationSizeGranularity, sizeof(float));
+    vkStream->read((VkBool32*)&forUnmarshaling->primitiveUnderestimation, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->conservativePointAndLineRasterization, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->degenerateTrianglesRasterized, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->degenerateLinesRasterized, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->fullyCoveredFragmentShaderInputVariable, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->conservativeRasterizationPostDepthCoverage, sizeof(VkBool32));
+}
+
+void marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
+    vkStream->write((VkConservativeRasterizationModeEXT*)&forMarshaling->conservativeRasterizationMode, sizeof(VkConservativeRasterizationModeEXT));
+    vkStream->write((float*)&forMarshaling->extraPrimitiveOverestimationSize, sizeof(float));
+}
+
+void unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
+    vkStream->read((VkConservativeRasterizationModeEXT*)&forUnmarshaling->conservativeRasterizationMode, sizeof(VkConservativeRasterizationModeEXT));
+    vkStream->read((float*)&forUnmarshaling->extraPrimitiveOverestimationSize, sizeof(float));
+}
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void marshal_VkXYColorEXT(
+    VulkanStream* vkStream,
+    const VkXYColorEXT* forMarshaling)
+{
+    vkStream->write((float*)&forMarshaling->x, sizeof(float));
+    vkStream->write((float*)&forMarshaling->y, sizeof(float));
+}
+
+void unmarshal_VkXYColorEXT(
+    VulkanStream* vkStream,
+    VkXYColorEXT* forUnmarshaling)
+{
+    vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
+}
+
+void marshal_VkHdrMetadataEXT(
+    VulkanStream* vkStream,
+    const VkHdrMetadataEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryRed));
+    marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryGreen));
+    marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryBlue));
+    marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->whitePoint));
+    vkStream->write((float*)&forMarshaling->maxLuminance, sizeof(float));
+    vkStream->write((float*)&forMarshaling->minLuminance, sizeof(float));
+    vkStream->write((float*)&forMarshaling->maxContentLightLevel, sizeof(float));
+    vkStream->write((float*)&forMarshaling->maxFrameAverageLightLevel, sizeof(float));
+}
+
+void unmarshal_VkHdrMetadataEXT(
+    VulkanStream* vkStream,
+    VkHdrMetadataEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryRed));
+    unmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryGreen));
+    unmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryBlue));
+    unmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forUnmarshaling->whitePoint));
+    vkStream->read((float*)&forUnmarshaling->maxLuminance, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->minLuminance, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->maxContentLightLevel, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->maxFrameAverageLightLevel, sizeof(float));
+}
+
+#endif
+#ifdef VK_MVK_ios_surface
+void marshal_VkIOSSurfaceCreateInfoMVK(
+    VulkanStream* vkStream,
+    const VkIOSSurfaceCreateInfoMVK* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_326 = (uint64_t)(uintptr_t)forMarshaling->pView;
+    vkStream->putBe64(cgen_var_326);
+    if (forMarshaling->pView)
+    {
+        vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
+    }
+}
+
+void unmarshal_VkIOSSurfaceCreateInfoMVK(
+    VulkanStream* vkStream,
+    VkIOSSurfaceCreateInfoMVK* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkIOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
+    // WARNING PTR CHECK
+    forUnmarshaling->pView = (const void*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pView)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pView, sizeof(const uint8_t));
+        vkStream->read((void*)forUnmarshaling->pView, sizeof(const uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_MVK_macos_surface
+void marshal_VkMacOSSurfaceCreateInfoMVK(
+    VulkanStream* vkStream,
+    const VkMacOSSurfaceCreateInfoMVK* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_328 = (uint64_t)(uintptr_t)forMarshaling->pView;
+    vkStream->putBe64(cgen_var_328);
+    if (forMarshaling->pView)
+    {
+        vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
+    }
+}
+
+void unmarshal_VkMacOSSurfaceCreateInfoMVK(
+    VulkanStream* vkStream,
+    VkMacOSSurfaceCreateInfoMVK* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkMacOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
+    // WARNING PTR CHECK
+    forUnmarshaling->pView = (const void*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pView)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pView, sizeof(const uint8_t));
+        vkStream->read((void*)forUnmarshaling->pView, sizeof(const uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void marshal_VkDebugUtilsObjectNameInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugUtilsObjectNameInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
+    vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
+    vkStream->putString(forMarshaling->pObjectName);
+}
+
+void unmarshal_VkDebugUtilsObjectNameInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugUtilsObjectNameInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
+    vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
+    vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
+}
+
+void marshal_VkDebugUtilsObjectTagInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugUtilsObjectTagInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
+    vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
+    vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
+    uint64_t cgen_var_330 = (uint64_t)forMarshaling->tagSize;
+    vkStream->putBe64(cgen_var_330);
+    vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkDebugUtilsObjectTagInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugUtilsObjectTagInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
+    vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->tagName, sizeof(uint64_t));
+    forUnmarshaling->tagSize = (size_t)vkStream->getBe64();
+    vkStream->alloc((void**)&forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
+    vkStream->read((void*)forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
+}
+
+void marshal_VkDebugUtilsLabelEXT(
+    VulkanStream* vkStream,
+    const VkDebugUtilsLabelEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->putString(forMarshaling->pLabelName);
+    vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
+}
+
+void unmarshal_VkDebugUtilsLabelEXT(
+    VulkanStream* vkStream,
+    VkDebugUtilsLabelEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->loadStringInPlace((char**)&forUnmarshaling->pLabelName);
+    vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
+}
+
+void marshal_VkDebugUtilsMessengerCallbackDataEXT(
+    VulkanStream* vkStream,
+    const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
+    vkStream->putString(forMarshaling->pMessageIdName);
+    vkStream->write((int32_t*)&forMarshaling->messageIdNumber, sizeof(int32_t));
+    vkStream->putString(forMarshaling->pMessage);
+    vkStream->write((uint32_t*)&forMarshaling->queueLabelCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_332 = (uint64_t)(uintptr_t)forMarshaling->pQueueLabels;
+    vkStream->putBe64(cgen_var_332);
+    if (forMarshaling->pQueueLabels)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i)
+        {
+            marshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i));
+        }
+    }
+    vkStream->write((uint32_t*)&forMarshaling->cmdBufLabelCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_333 = (uint64_t)(uintptr_t)forMarshaling->pCmdBufLabels;
+    vkStream->putBe64(cgen_var_333);
+    if (forMarshaling->pCmdBufLabels)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i)
+        {
+            marshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i));
+        }
+    }
+    vkStream->write((uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_334 = (uint64_t)(uintptr_t)forMarshaling->pObjects;
+    vkStream->putBe64(cgen_var_334);
+    if (forMarshaling->pObjects)
+    {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i)
+        {
+            marshal_VkDebugUtilsObjectNameInfoEXT(vkStream, (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i));
+        }
+    }
+}
+
+void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
+    VulkanStream* vkStream,
+    VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
+    vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
+    vkStream->read((int32_t*)&forUnmarshaling->messageIdNumber, sizeof(int32_t));
+    vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessage);
+    vkStream->read((uint32_t*)&forUnmarshaling->queueLabelCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pQueueLabels = (VkDebugUtilsLabelEXT*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pQueueLabels)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pQueueLabels, forUnmarshaling->queueLabelCount * sizeof(VkDebugUtilsLabelEXT));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i)
+        {
+            unmarshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i));
+        }
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->cmdBufLabelCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pCmdBufLabels = (VkDebugUtilsLabelEXT*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pCmdBufLabels)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pCmdBufLabels, forUnmarshaling->cmdBufLabelCount * sizeof(VkDebugUtilsLabelEXT));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i)
+        {
+            unmarshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i));
+        }
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->objectCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pObjects = (VkDebugUtilsObjectNameInfoEXT*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pObjects)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pObjects, forUnmarshaling->objectCount * sizeof(VkDebugUtilsObjectNameInfoEXT));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i)
+        {
+            unmarshal_VkDebugUtilsObjectNameInfoEXT(vkStream, (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i));
+        }
+    }
+}
+
+void marshal_VkDebugUtilsMessengerCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDebugUtilsMessengerCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
+    vkStream->write((VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
+    vkStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&forMarshaling->messageType, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+    uint64_t cgen_var_338 = (uint64_t)forMarshaling->pfnUserCallback;
+    vkStream->putBe64(cgen_var_338);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_339 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+    vkStream->putBe64(cgen_var_339);
+    if (forMarshaling->pUserData)
+    {
+        vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
+    }
+}
+
+void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDebugUtilsMessengerCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
+    vkStream->read((VkDebugUtilsMessageSeverityFlagsEXT*)&forUnmarshaling->messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
+    vkStream->read((VkDebugUtilsMessageTypeFlagsEXT*)&forUnmarshaling->messageType, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+    forUnmarshaling->pfnUserCallback = (PFN_vkDebugUtilsMessengerCallbackEXT)vkStream->getBe64();
+    // WARNING PTR CHECK
+    forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pUserData)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
+        vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void marshal_VkAndroidHardwareBufferUsageANDROID(
+    VulkanStream* vkStream,
+    const VkAndroidHardwareBufferUsageANDROID* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint64_t*)&forMarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
+}
+
+void unmarshal_VkAndroidHardwareBufferUsageANDROID(
+    VulkanStream* vkStream,
+    VkAndroidHardwareBufferUsageANDROID* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint64_t*)&forUnmarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
+}
+
+void marshal_VkAndroidHardwareBufferPropertiesANDROID(
+    VulkanStream* vkStream,
+    const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
+    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
+    VulkanStream* vkStream,
+    VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->allocationSize, sizeof(VkDeviceSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+    VulkanStream* vkStream,
+    const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
+    vkStream->write((VkFormatFeatureFlags*)&forMarshaling->formatFeatures, sizeof(VkFormatFeatureFlags));
+    marshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
+    vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+    vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
+    vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
+    vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+}
+
+void unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+    VulkanStream* vkStream,
+    VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
+    vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->formatFeatures, sizeof(VkFormatFeatureFlags));
+    unmarshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
+    vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+    vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
+    vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
+    vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+}
+
+void marshal_VkImportAndroidHardwareBufferInfoANDROID(
+    VulkanStream* vkStream,
+    const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((AHardwareBuffer*)forMarshaling->buffer, sizeof(AHardwareBuffer));
+}
+
+void unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
+    VulkanStream* vkStream,
+    VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->buffer, sizeof(AHardwareBuffer));
+    vkStream->read((AHardwareBuffer*)forUnmarshaling->buffer, sizeof(AHardwareBuffer));
+}
+
+void marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+    VulkanStream* vkStream,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_342;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_342, 1);
+    vkStream->write((uint64_t*)&cgen_var_342, 1 * 8);
+}
+
+void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+    VulkanStream* vkStream,
+    VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_343;
+    vkStream->read((uint64_t*)&cgen_var_343, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_343, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+}
+
+void marshal_VkExternalFormatANDROID(
+    VulkanStream* vkStream,
+    const VkExternalFormatANDROID* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
+}
+
+void unmarshal_VkExternalFormatANDROID(
+    VulkanStream* vkStream,
+    VkExternalFormatANDROID* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
+}
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void marshal_VkSamplerReductionModeCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkSamplerReductionModeCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkSamplerReductionModeEXT*)&forMarshaling->reductionMode, sizeof(VkSamplerReductionModeEXT));
+}
+
+void unmarshal_VkSamplerReductionModeCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkSamplerReductionModeCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkSamplerReductionModeEXT*)&forUnmarshaling->reductionMode, sizeof(VkSamplerReductionModeEXT));
+}
+
+void marshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void marshal_VkSampleLocationEXT(
+    VulkanStream* vkStream,
+    const VkSampleLocationEXT* forMarshaling)
+{
+    vkStream->write((float*)&forMarshaling->x, sizeof(float));
+    vkStream->write((float*)&forMarshaling->y, sizeof(float));
+}
+
+void unmarshal_VkSampleLocationEXT(
+    VulkanStream* vkStream,
+    VkSampleLocationEXT* forUnmarshaling)
+{
+    vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
+    vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
+}
+
+void marshal_VkSampleLocationsInfoEXT(
+    VulkanStream* vkStream,
+    const VkSampleLocationsInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->sampleLocationsPerPixel, sizeof(VkSampleCountFlagBits));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->sampleLocationGridSize));
+    vkStream->write((uint32_t*)&forMarshaling->sampleLocationsCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationsCount; ++i)
+    {
+        marshal_VkSampleLocationEXT(vkStream, (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i));
+    }
+}
+
+void unmarshal_VkSampleLocationsInfoEXT(
+    VulkanStream* vkStream,
+    VkSampleLocationsInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->sampleLocationsPerPixel, sizeof(VkSampleCountFlagBits));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->sampleLocationGridSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->sampleLocationsCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSampleLocations, forUnmarshaling->sampleLocationsCount * sizeof(const VkSampleLocationEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->sampleLocationsCount; ++i)
+    {
+        unmarshal_VkSampleLocationEXT(vkStream, (VkSampleLocationEXT*)(forUnmarshaling->pSampleLocations + i));
+    }
+}
+
+void marshal_VkAttachmentSampleLocationsEXT(
+    VulkanStream* vkStream,
+    const VkAttachmentSampleLocationsEXT* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->attachmentIndex, sizeof(uint32_t));
+    marshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+}
+
+void unmarshal_VkAttachmentSampleLocationsEXT(
+    VulkanStream* vkStream,
+    VkAttachmentSampleLocationsEXT* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->attachmentIndex, sizeof(uint32_t));
+    unmarshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+}
+
+void marshal_VkSubpassSampleLocationsEXT(
+    VulkanStream* vkStream,
+    const VkSubpassSampleLocationsEXT* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->subpassIndex, sizeof(uint32_t));
+    marshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+}
+
+void unmarshal_VkSubpassSampleLocationsEXT(
+    VulkanStream* vkStream,
+    VkSubpassSampleLocationsEXT* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->subpassIndex, sizeof(uint32_t));
+    unmarshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+}
+
+void marshal_VkRenderPassSampleLocationsBeginInfoEXT(
+    VulkanStream* vkStream,
+    const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->attachmentInitialSampleLocationsCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentInitialSampleLocationsCount; ++i)
+    {
+        marshal_VkAttachmentSampleLocationsEXT(vkStream, (const VkAttachmentSampleLocationsEXT*)(forMarshaling->pAttachmentInitialSampleLocations + i));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->postSubpassSampleLocationsCount; ++i)
+    {
+        marshal_VkSubpassSampleLocationsEXT(vkStream, (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations + i));
+    }
+}
+
+void unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
+    VulkanStream* vkStream,
+    VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->attachmentInitialSampleLocationsCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pAttachmentInitialSampleLocations, forUnmarshaling->attachmentInitialSampleLocationsCount * sizeof(const VkAttachmentSampleLocationsEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentInitialSampleLocationsCount; ++i)
+    {
+        unmarshal_VkAttachmentSampleLocationsEXT(vkStream, (VkAttachmentSampleLocationsEXT*)(forUnmarshaling->pAttachmentInitialSampleLocations + i));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pPostSubpassSampleLocations, forUnmarshaling->postSubpassSampleLocationsCount * sizeof(const VkSubpassSampleLocationsEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->postSubpassSampleLocationsCount; ++i)
+    {
+        unmarshal_VkSubpassSampleLocationsEXT(vkStream, (VkSubpassSampleLocationsEXT*)(forUnmarshaling->pPostSubpassSampleLocations + i));
+    }
+}
+
+void marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->sampleLocationsEnable, sizeof(VkBool32));
+    marshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+}
+
+void unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->sampleLocationsEnable, sizeof(VkBool32));
+    unmarshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+}
+
+void marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkSampleCountFlags*)&forMarshaling->sampleLocationSampleCounts, sizeof(VkSampleCountFlags));
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
+    vkStream->write((float*)forMarshaling->sampleLocationCoordinateRange, 2 * sizeof(float));
+    vkStream->write((uint32_t*)&forMarshaling->sampleLocationSubPixelBits, sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->variableSampleLocations, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampleLocationSampleCounts, sizeof(VkSampleCountFlags));
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
+    vkStream->read((float*)forUnmarshaling->sampleLocationCoordinateRange, 2 * sizeof(float));
+    vkStream->read((uint32_t*)&forUnmarshaling->sampleLocationSubPixelBits, sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->variableSampleLocations, sizeof(VkBool32));
+}
+
+void marshal_VkMultisamplePropertiesEXT(
+    VulkanStream* vkStream,
+    const VkMultisamplePropertiesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
+}
+
+void unmarshal_VkMultisamplePropertiesEXT(
+    VulkanStream* vkStream,
+    VkMultisamplePropertiesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
+}
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->advancedBlendMaxColorAttachments, sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->advancedBlendIndependentBlend, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->advancedBlendNonPremultipliedSrcColor, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->advancedBlendNonPremultipliedDstColor, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->advancedBlendCorrelatedOverlap, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->advancedBlendAllOperations, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->advancedBlendMaxColorAttachments, sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendIndependentBlend, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendNonPremultipliedSrcColor, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendNonPremultipliedDstColor, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendCorrelatedOverlap, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendAllOperations, sizeof(VkBool32));
+}
+
+void marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->srcPremultiplied, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->dstPremultiplied, sizeof(VkBool32));
+    vkStream->write((VkBlendOverlapEXT*)&forMarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
+}
+
+void unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->srcPremultiplied, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->dstPremultiplied, sizeof(VkBool32));
+    vkStream->read((VkBlendOverlapEXT*)&forUnmarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
+}
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void marshal_VkPipelineCoverageToColorStateCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineCoverageToColorStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineCoverageToColorStateCreateFlagsNV));
+    vkStream->write((VkBool32*)&forMarshaling->coverageToColorEnable, sizeof(VkBool32));
+    vkStream->write((uint32_t*)&forMarshaling->coverageToColorLocation, sizeof(uint32_t));
+}
+
+void unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
+    VulkanStream* vkStream,
+    VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineCoverageToColorStateCreateFlagsNV*)&forUnmarshaling->flags, sizeof(VkPipelineCoverageToColorStateCreateFlagsNV));
+    vkStream->read((VkBool32*)&forUnmarshaling->coverageToColorEnable, sizeof(VkBool32));
+    vkStream->read((uint32_t*)&forUnmarshaling->coverageToColorLocation, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void marshal_VkPipelineCoverageModulationStateCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineCoverageModulationStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
+    vkStream->write((VkCoverageModulationModeNV*)&forMarshaling->coverageModulationMode, sizeof(VkCoverageModulationModeNV));
+    vkStream->write((VkBool32*)&forMarshaling->coverageModulationTableEnable, sizeof(VkBool32));
+    vkStream->write((uint32_t*)&forMarshaling->coverageModulationTableCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_344 = (uint64_t)(uintptr_t)forMarshaling->pCoverageModulationTable;
+    vkStream->putBe64(cgen_var_344);
+    if (forMarshaling->pCoverageModulationTable)
+    {
+        vkStream->write((const float*)forMarshaling->pCoverageModulationTable, forMarshaling->coverageModulationTableCount * sizeof(const float));
+    }
+}
+
+void unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
+    VulkanStream* vkStream,
+    VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineCoverageModulationStateCreateFlagsNV*)&forUnmarshaling->flags, sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
+    vkStream->read((VkCoverageModulationModeNV*)&forUnmarshaling->coverageModulationMode, sizeof(VkCoverageModulationModeNV));
+    vkStream->read((VkBool32*)&forUnmarshaling->coverageModulationTableEnable, sizeof(VkBool32));
+    vkStream->read((uint32_t*)&forUnmarshaling->coverageModulationTableCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pCoverageModulationTable = (const float*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pCoverageModulationTable)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pCoverageModulationTable, forUnmarshaling->coverageModulationTableCount * sizeof(const float));
+        vkStream->read((float*)forUnmarshaling->pCoverageModulationTable, forUnmarshaling->coverageModulationTableCount * sizeof(const float));
+    }
+}
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void marshal_VkValidationCacheCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkValidationCacheCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
+    uint64_t cgen_var_346 = (uint64_t)forMarshaling->initialDataSize;
+    vkStream->putBe64(cgen_var_346);
+    vkStream->write((const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkValidationCacheCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkValidationCacheCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkValidationCacheCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
+    forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
+    vkStream->alloc((void**)&forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
+    vkStream->read((void*)forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
+}
+
+void marshal_VkShaderModuleValidationCacheCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    uint64_t cgen_var_348;
+    vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache, &cgen_var_348, 1);
+    vkStream->write((uint64_t*)&cgen_var_348, 1 * 8);
+}
+
+void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_349;
+    vkStream->read((uint64_t*)&cgen_var_349, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_349, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
+}
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void marshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
+    vkStream->write((const VkDescriptorBindingFlagsEXT*)forMarshaling->pBindingFlags, forMarshaling->bindingCount * sizeof(const VkDescriptorBindingFlagsEXT));
+}
+
+void unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pBindingFlags, forUnmarshaling->bindingCount * sizeof(const VkDescriptorBindingFlagsEXT));
+    vkStream->read((VkDescriptorBindingFlagsEXT*)forUnmarshaling->pBindingFlags, forUnmarshaling->bindingCount * sizeof(const VkDescriptorBindingFlagsEXT));
+}
+
+void marshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->runtimeDescriptorArray, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceDescriptorIndexingFeaturesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformBufferUpdateAfterBind, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingSampledImageUpdateAfterBind, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageImageUpdateAfterBind, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageBufferUpdateAfterBind, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUpdateUnusedWhilePending, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingVariableDescriptorCount, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->runtimeDescriptorArray, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools, sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageUpdateAfterBindResources, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceDescriptorIndexingPropertiesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxUpdateAfterBindDescriptorsInAllPools, sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexingNative, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSamplers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageUpdateAfterBindResources, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSamplers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSampledImages, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageImages, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInputAttachments, sizeof(uint32_t));
+}
+
+void marshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+    VulkanStream* vkStream,
+    const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pDescriptorCounts, forMarshaling->descriptorSetCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+    VulkanStream* vkStream,
+    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDescriptorCounts, forUnmarshaling->descriptorSetCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pDescriptorCounts, forUnmarshaling->descriptorSetCount * sizeof(const uint32_t));
+}
+
+void marshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+    VulkanStream* vkStream,
+    const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+    VulkanStream* vkStream,
+    VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkQueueGlobalPriorityEXT*)&forMarshaling->globalPriority, sizeof(VkQueueGlobalPriorityEXT));
+}
+
+void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkQueueGlobalPriorityEXT*)&forUnmarshaling->globalPriority, sizeof(VkQueueGlobalPriorityEXT));
+}
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void marshal_VkImportMemoryHostPointerInfoEXT(
+    VulkanStream* vkStream,
+    const VkImportMemoryHostPointerInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_350 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
+    vkStream->putBe64(cgen_var_350);
+    if (forMarshaling->pHostPointer)
+    {
+        vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
+    }
+}
+
+void unmarshal_VkImportMemoryHostPointerInfoEXT(
+    VulkanStream* vkStream,
+    VkImportMemoryHostPointerInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+    // WARNING PTR CHECK
+    forUnmarshaling->pHostPointer = (void*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pHostPointer)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pHostPointer, sizeof(uint8_t));
+        vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(uint8_t));
+    }
+}
+
+void marshal_VkMemoryHostPointerPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkMemoryHostPointerPropertiesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryHostPointerPropertiesEXT(
+    VulkanStream* vkStream,
+    VkMemoryHostPointerPropertiesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkDeviceSize*)&forMarshaling->minImportedHostPointerAlignment, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->minImportedHostPointerAlignment, sizeof(VkDeviceSize));
+}
+
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+void marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->shaderEngineCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->shaderArraysPerEngineCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->computeUnitsPerShaderArray, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->simdPerComputeUnit, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->wavefrontsPerSimd, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->wavefrontSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->sgprsPerSimd, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minSgprAllocation, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxSgprAllocation, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->sgprAllocationGranularity, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->vgprsPerSimd, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minVgprAllocation, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxVgprAllocation, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->vgprAllocationGranularity, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->shaderEngineCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->shaderArraysPerEngineCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->computeUnitsPerShaderArray, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->simdPerComputeUnit, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->wavefrontsPerSimd, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->wavefrontSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->sgprsPerSimd, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minSgprAllocation, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxSgprAllocation, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->sgprAllocationGranularity, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->vgprsPerSimd, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minVgprAllocation, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxVgprAllocation, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->vgprAllocationGranularity, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
+}
+
+void marshal_VkVertexInputBindingDivisorDescriptionEXT(
+    VulkanStream* vkStream,
+    const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling)
+{
+    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->divisor, sizeof(uint32_t));
+}
+
+void unmarshal_VkVertexInputBindingDivisorDescriptionEXT(
+    VulkanStream* vkStream,
+    VkVertexInputBindingDivisorDescriptionEXT* forUnmarshaling)
+{
+    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->divisor, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDivisorCount; ++i)
+    {
+        marshal_VkVertexInputBindingDivisorDescriptionEXT(vkStream, (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling->pVertexBindingDivisors + i));
+    }
+}
+
+void unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pVertexBindingDivisors, forUnmarshaling->vertexBindingDivisorCount * sizeof(const VkVertexInputBindingDivisorDescriptionEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDivisorCount; ++i)
+    {
+        unmarshal_VkVertexInputBindingDivisorDescriptionEXT(vkStream, (VkVertexInputBindingDivisorDescriptionEXT*)(forUnmarshaling->pVertexBindingDivisors + i));
+    }
+}
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void marshal_VkQueueFamilyCheckpointPropertiesNV(
+    VulkanStream* vkStream,
+    const VkQueueFamilyCheckpointPropertiesNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineStageFlags*)&forMarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags));
+}
+
+void unmarshal_VkQueueFamilyCheckpointPropertiesNV(
+    VulkanStream* vkStream,
+    VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags));
+}
+
+void marshal_VkCheckpointDataNV(
+    VulkanStream* vkStream,
+    const VkCheckpointDataNV* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+    vkStream->putBe32(pNext_size);
+    if (pNext_size)
+    {
+        vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+        marshal_extension_struct(vkStream, forMarshaling->pNext);
+    }
+    vkStream->write((VkPipelineStageFlagBits*)&forMarshaling->stage, sizeof(VkPipelineStageFlagBits));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_352 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
+    vkStream->putBe64(cgen_var_352);
+    if (forMarshaling->pCheckpointMarker)
+    {
+        vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
+    }
+}
+
+void unmarshal_VkCheckpointDataNV(
+    VulkanStream* vkStream,
+    VkCheckpointDataNV* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineStageFlagBits*)&forUnmarshaling->stage, sizeof(VkPipelineStageFlagBits));
+    // WARNING PTR CHECK
+    forUnmarshaling->pCheckpointMarker = (void*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pCheckpointMarker)
+    {
+        vkStream->alloc((void**)&forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
+        vkStream->read((void*)forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
+    }
+}
+
+#endif
+void marshal_extension_struct(
+    VulkanStream* vkStream,
+    const void* structExtension)
+{
+    if (!structExtension)
+    {
+        return;
+    }
+    uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
+    switch(structType)
+    {
+#ifdef VK_VERSION_1_1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+        {
+            marshal_VkPhysicalDeviceSubgroupProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+        {
+            marshal_VkPhysicalDevice16BitStorageFeatures(vkStream, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+        {
+            marshal_VkMemoryDedicatedRequirements(vkStream, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+        {
+            marshal_VkMemoryDedicatedAllocateInfo(vkStream, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+        {
+            marshal_VkMemoryAllocateFlagsInfo(vkStream, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+        {
+            marshal_VkDeviceGroupRenderPassBeginInfo(vkStream, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+        {
+            marshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+        {
+            marshal_VkDeviceGroupSubmitInfo(vkStream, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+        {
+            marshal_VkDeviceGroupBindSparseInfo(vkStream, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+        {
+            marshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+        {
+            marshal_VkBindImageMemoryDeviceGroupInfo(vkStream, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+        {
+            marshal_VkDeviceGroupDeviceCreateInfo(vkStream, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+        {
+            marshal_VkPhysicalDeviceFeatures2(vkStream, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+        {
+            marshal_VkPhysicalDevicePointClippingProperties(vkStream, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+        {
+            marshal_VkRenderPassInputAttachmentAspectCreateInfo(vkStream, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+        {
+            marshal_VkImageViewUsageCreateInfo(vkStream, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+        {
+            marshal_VkPipelineTessellationDomainOriginStateCreateInfo(vkStream, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+        {
+            marshal_VkRenderPassMultiviewCreateInfo(vkStream, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+        {
+            marshal_VkPhysicalDeviceMultiviewFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+        {
+            marshal_VkPhysicalDeviceMultiviewProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
+        {
+            marshal_VkPhysicalDeviceVariablePointerFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceVariablePointerFeatures*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+        {
+            marshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+        {
+            marshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+        {
+            marshal_VkProtectedSubmitInfo(vkStream, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+        {
+            marshal_VkSamplerYcbcrConversionInfo(vkStream, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+        {
+            marshal_VkBindImagePlaneMemoryInfo(vkStream, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+        {
+            marshal_VkImagePlaneMemoryRequirementsInfo(vkStream, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+        {
+            marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+        {
+            marshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+        {
+            marshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+        {
+            marshal_VkExternalImageFormatProperties(vkStream, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+        {
+            marshal_VkPhysicalDeviceIDProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+        {
+            marshal_VkExternalMemoryImageCreateInfo(vkStream, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+        {
+            marshal_VkExternalMemoryBufferCreateInfo(vkStream, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+        {
+            marshal_VkExportMemoryAllocateInfo(vkStream, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+        {
+            marshal_VkExportFenceCreateInfo(vkStream, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+        {
+            marshal_VkExportSemaphoreCreateInfo(vkStream, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+        {
+            marshal_VkPhysicalDeviceMaintenance3Properties(vkStream, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
+        {
+            marshal_VkPhysicalDeviceShaderDrawParameterFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderDrawParameterFeatures*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_swapchain
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+        {
+            marshal_VkImageSwapchainCreateInfoKHR(vkStream, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+        {
+            marshal_VkBindImageMemorySwapchainInfoKHR(vkStream, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+        {
+            marshal_VkDeviceGroupPresentInfoKHR(vkStream, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+        {
+            marshal_VkDeviceGroupSwapchainCreateInfoKHR(vkStream, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_display_swapchain
+        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+        {
+            marshal_VkDisplayPresentInfoKHR(vkStream, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_memory_win32
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            marshal_VkImportMemoryWin32HandleInfoKHR(vkStream, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            marshal_VkExportMemoryWin32HandleInfoKHR(vkStream, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_memory_fd
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+        {
+            marshal_VkImportMemoryFdInfoKHR(vkStream, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+        {
+            marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(vkStream, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+        {
+            marshal_VkExportSemaphoreWin32HandleInfoKHR(vkStream, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+        {
+            marshal_VkD3D12FenceSubmitInfoKHR(vkStream, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_push_descriptor
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+        {
+            marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(vkStream, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_incremental_present
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+        {
+            marshal_VkPresentRegionsKHR(vkStream, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+        {
+            marshal_VkSharedPresentSurfaceCapabilitiesKHR(vkStream, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_fence_win32
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+        {
+            marshal_VkExportFenceWin32HandleInfoKHR(vkStream, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_image_format_list
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+        {
+            marshal_VkImageFormatListCreateInfoKHR(vkStream, reinterpret_cast<const VkImageFormatListCreateInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_8bit_storage
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+        {
+            marshal_VkPhysicalDevice8BitStorageFeaturesKHR(vkStream, reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_ANDROID_native_buffer
+        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
+        {
+            marshal_VkNativeBufferANDROID(vkStream, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_debug_report
+        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+        {
+            marshal_VkDebugReportCallbackCreateInfoEXT(vkStream, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_AMD_rasterization_order
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+        {
+            marshal_VkPipelineRasterizationStateRasterizationOrderAMD(vkStream, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_dedicated_allocation
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+        {
+            marshal_VkDedicatedAllocationImageCreateInfoNV(vkStream, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+        {
+            marshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+        {
+            marshal_VkDedicatedAllocationMemoryAllocateInfoNV(vkStream, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+        {
+            marshal_VkTextureLODGatherFormatPropertiesAMD(vkStream, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_external_memory
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+        {
+            marshal_VkExternalMemoryImageCreateInfoNV(vkStream, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+        {
+            marshal_VkExportMemoryAllocateInfoNV(vkStream, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_external_memory_win32
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+        {
+            marshal_VkImportMemoryWin32HandleInfoNV(vkStream, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+        {
+            marshal_VkExportMemoryWin32HandleInfoNV(vkStream, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+        {
+            marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(vkStream, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_validation_flags
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+        {
+            marshal_VkValidationFlagsEXT(vkStream, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_conditional_rendering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+        {
+            marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+        {
+            marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkStream, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+        {
+            marshal_VkPipelineViewportWScalingStateCreateInfoNV(vkStream, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_display_control
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+        {
+            marshal_VkSwapchainCounterCreateInfoEXT(vkStream, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_GOOGLE_display_timing
+        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+        {
+            marshal_VkPresentTimesInfoGOOGLE(vkStream, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+        {
+            marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(vkStream, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_viewport_swizzle
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+        {
+            marshal_VkPipelineViewportSwizzleStateCreateInfoNV(vkStream, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_discard_rectangles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+        {
+            marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+        {
+            marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_conservative_rasterization
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+        {
+            marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+        {
+            marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+        {
+            marshal_VkDebugUtilsMessengerCreateInfoEXT(vkStream, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+        {
+            marshal_VkAndroidHardwareBufferUsageANDROID(vkStream, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+        {
+            marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+        {
+            marshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+        {
+            marshal_VkExternalFormatANDROID(vkStream, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+        {
+            marshal_VkSamplerReductionModeCreateInfoEXT(vkStream, reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+        {
+            marshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_sample_locations
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+        {
+            marshal_VkSampleLocationsInfoEXT(vkStream, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+        {
+            marshal_VkRenderPassSampleLocationsBeginInfoEXT(vkStream, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+        {
+            marshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+        {
+            marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+        {
+            marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+        {
+            marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+        {
+            marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+        {
+            marshal_VkPipelineCoverageToColorStateCreateInfoNV(vkStream, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+        {
+            marshal_VkPipelineCoverageModulationStateCreateInfoNV(vkStream, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_validation_cache
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+        {
+            marshal_VkShaderModuleValidationCacheCreateInfoEXT(vkStream, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_indexing
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+        {
+            marshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(vkStream, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+        {
+            marshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+        {
+            marshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+        {
+            marshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(vkStream, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+        {
+            marshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(vkStream, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
+        {
+            marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(vkStream, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_external_memory_host
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+        {
+            marshal_VkImportMemoryHostPointerInfoEXT(vkStream, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+        {
+            marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+        {
+            marshal_VkPhysicalDeviceShaderCorePropertiesAMD(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+        {
+            marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+        {
+            marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+        {
+            marshal_VkQueueFamilyCheckpointPropertiesNV(vkStream, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension));
+            break;
+        }
+#endif
+        default:
+        {
+            return;
+        }
+    }
+}
+
+void unmarshal_extension_struct(
+    VulkanStream* vkStream,
+    void* structExtension_out)
+{
+    if (!structExtension_out)
+    {
+        return;
+    }
+    uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
+    switch(structType)
+    {
+#ifdef VK_VERSION_1_1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+        {
+            unmarshal_VkPhysicalDeviceSubgroupProperties(vkStream, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+        {
+            unmarshal_VkPhysicalDevice16BitStorageFeatures(vkStream, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+        {
+            unmarshal_VkMemoryDedicatedRequirements(vkStream, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+        {
+            unmarshal_VkMemoryDedicatedAllocateInfo(vkStream, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+        {
+            unmarshal_VkMemoryAllocateFlagsInfo(vkStream, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+        {
+            unmarshal_VkDeviceGroupRenderPassBeginInfo(vkStream, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+        {
+            unmarshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+        {
+            unmarshal_VkDeviceGroupSubmitInfo(vkStream, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+        {
+            unmarshal_VkDeviceGroupBindSparseInfo(vkStream, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+        {
+            unmarshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+        {
+            unmarshal_VkBindImageMemoryDeviceGroupInfo(vkStream, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+        {
+            unmarshal_VkDeviceGroupDeviceCreateInfo(vkStream, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+        {
+            unmarshal_VkPhysicalDeviceFeatures2(vkStream, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+        {
+            unmarshal_VkPhysicalDevicePointClippingProperties(vkStream, reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+        {
+            unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(vkStream, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+        {
+            unmarshal_VkImageViewUsageCreateInfo(vkStream, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+        {
+            unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(vkStream, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+        {
+            unmarshal_VkRenderPassMultiviewCreateInfo(vkStream, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+        {
+            unmarshal_VkPhysicalDeviceMultiviewFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+        {
+            unmarshal_VkPhysicalDeviceMultiviewProperties(vkStream, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
+        {
+            unmarshal_VkPhysicalDeviceVariablePointerFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+        {
+            unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+        {
+            unmarshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+        {
+            unmarshal_VkProtectedSubmitInfo(vkStream, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+        {
+            unmarshal_VkSamplerYcbcrConversionInfo(vkStream, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+        {
+            unmarshal_VkBindImagePlaneMemoryInfo(vkStream, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+        {
+            unmarshal_VkImagePlaneMemoryRequirementsInfo(vkStream, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+        {
+            unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+        {
+            unmarshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+        {
+            unmarshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+        {
+            unmarshal_VkExternalImageFormatProperties(vkStream, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+        {
+            unmarshal_VkPhysicalDeviceIDProperties(vkStream, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+        {
+            unmarshal_VkExternalMemoryImageCreateInfo(vkStream, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+        {
+            unmarshal_VkExternalMemoryBufferCreateInfo(vkStream, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+        {
+            unmarshal_VkExportMemoryAllocateInfo(vkStream, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+        {
+            unmarshal_VkExportFenceCreateInfo(vkStream, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+        {
+            unmarshal_VkExportSemaphoreCreateInfo(vkStream, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+        {
+            unmarshal_VkPhysicalDeviceMaintenance3Properties(vkStream, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
+        {
+            unmarshal_VkPhysicalDeviceShaderDrawParameterFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_swapchain
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+        {
+            unmarshal_VkImageSwapchainCreateInfoKHR(vkStream, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+        {
+            unmarshal_VkBindImageMemorySwapchainInfoKHR(vkStream, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+        {
+            unmarshal_VkDeviceGroupPresentInfoKHR(vkStream, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+        {
+            unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(vkStream, reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_display_swapchain
+        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+        {
+            unmarshal_VkDisplayPresentInfoKHR(vkStream, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_memory_win32
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            unmarshal_VkImportMemoryWin32HandleInfoKHR(vkStream, reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            unmarshal_VkExportMemoryWin32HandleInfoKHR(vkStream, reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_memory_fd
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+        {
+            unmarshal_VkImportMemoryFdInfoKHR(vkStream, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+        {
+            unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(vkStream, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+        {
+            unmarshal_VkExportSemaphoreWin32HandleInfoKHR(vkStream, reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+        {
+            unmarshal_VkD3D12FenceSubmitInfoKHR(vkStream, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_push_descriptor
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+        {
+            unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(vkStream, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_incremental_present
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+        {
+            unmarshal_VkPresentRegionsKHR(vkStream, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+        {
+            unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(vkStream, reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_external_fence_win32
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+        {
+            unmarshal_VkExportFenceWin32HandleInfoKHR(vkStream, reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_image_format_list
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+        {
+            unmarshal_VkImageFormatListCreateInfoKHR(vkStream, reinterpret_cast<VkImageFormatListCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_8bit_storage
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+        {
+            unmarshal_VkPhysicalDevice8BitStorageFeaturesKHR(vkStream, reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ANDROID_native_buffer
+        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
+        {
+            unmarshal_VkNativeBufferANDROID(vkStream, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_debug_report
+        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+        {
+            unmarshal_VkDebugReportCallbackCreateInfoEXT(vkStream, reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_rasterization_order
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+        {
+            unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(vkStream, reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_dedicated_allocation
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+        {
+            unmarshal_VkDedicatedAllocationImageCreateInfoNV(vkStream, reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+        {
+            unmarshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+        {
+            unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(vkStream, reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+        {
+            unmarshal_VkTextureLODGatherFormatPropertiesAMD(vkStream, reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_external_memory
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+        {
+            unmarshal_VkExternalMemoryImageCreateInfoNV(vkStream, reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+        {
+            unmarshal_VkExportMemoryAllocateInfoNV(vkStream, reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_external_memory_win32
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+        {
+            unmarshal_VkImportMemoryWin32HandleInfoNV(vkStream, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+        {
+            unmarshal_VkExportMemoryWin32HandleInfoNV(vkStream, reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+        {
+            unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(vkStream, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_validation_flags
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+        {
+            unmarshal_VkValidationFlagsEXT(vkStream, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_conditional_rendering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+        {
+            unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkStream, reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+        {
+            unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(vkStream, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_display_control
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+        {
+            unmarshal_VkSwapchainCounterCreateInfoEXT(vkStream, reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_GOOGLE_display_timing
+        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+        {
+            unmarshal_VkPresentTimesInfoGOOGLE(vkStream, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+        {
+            unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(vkStream, reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_viewport_swizzle
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+        {
+            unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(vkStream, reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_discard_rectangles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+        {
+            unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_conservative_rasterization
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+        {
+            unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+        {
+            unmarshal_VkDebugUtilsMessengerCreateInfoEXT(vkStream, reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+        {
+            unmarshal_VkAndroidHardwareBufferUsageANDROID(vkStream, reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+        {
+            unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+        {
+            unmarshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+        {
+            unmarshal_VkExternalFormatANDROID(vkStream, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+        {
+            unmarshal_VkSamplerReductionModeCreateInfoEXT(vkStream, reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_sample_locations
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+        {
+            unmarshal_VkSampleLocationsInfoEXT(vkStream, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+        {
+            unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(vkStream, reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+        {
+            unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+        {
+            unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+        {
+            unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(vkStream, reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+        {
+            unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(vkStream, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_validation_cache
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+        {
+            unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(vkStream, reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_indexing
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+        {
+            unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(vkStream, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+        {
+            unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(vkStream, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+        {
+            unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(vkStream, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
+        {
+            unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(vkStream, reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_external_memory_host
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+        {
+            unmarshal_VkImportMemoryHostPointerInfoEXT(vkStream, reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+        {
+            unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(vkStream, reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+        {
+            unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+        {
+            unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+        {
+            unmarshal_VkQueueFamilyCheckpointPropertiesNV(vkStream, reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+            break;
+        }
+#endif
+        default:
+        {
+            return;
+        }
+    }
+}
+
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
new file mode 100644
index 0000000..a6ac11f
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -0,0 +1,3362 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_marshaling_guest
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "vk_platform_compat.h"
+
+#include "goldfish_vk_marshaling_guest.h"
+#include "goldfish_vk_private_defs.h"
+#include "VulkanStream.h"
+
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+void marshal_VkApplicationInfo(
+    VulkanStream* vkStream,
+    const VkApplicationInfo* forMarshaling);
+
+void unmarshal_VkApplicationInfo(
+    VulkanStream* vkStream,
+    VkApplicationInfo* forUnmarshaling);
+
+void marshal_VkInstanceCreateInfo(
+    VulkanStream* vkStream,
+    const VkInstanceCreateInfo* forMarshaling);
+
+void unmarshal_VkInstanceCreateInfo(
+    VulkanStream* vkStream,
+    VkInstanceCreateInfo* forUnmarshaling);
+
+void marshal_VkAllocationCallbacks(
+    VulkanStream* vkStream,
+    const VkAllocationCallbacks* forMarshaling);
+
+void unmarshal_VkAllocationCallbacks(
+    VulkanStream* vkStream,
+    VkAllocationCallbacks* forUnmarshaling);
+
+#define OP_vkCreateInstance 20000
+#define OP_vkDestroyInstance 20001
+#define OP_vkEnumeratePhysicalDevices 20002
+void marshal_VkPhysicalDeviceFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceFeatures* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceFeatures 20003
+void marshal_VkFormatProperties(
+    VulkanStream* vkStream,
+    const VkFormatProperties* forMarshaling);
+
+void unmarshal_VkFormatProperties(
+    VulkanStream* vkStream,
+    VkFormatProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceFormatProperties 20004
+void marshal_VkExtent3D(
+    VulkanStream* vkStream,
+    const VkExtent3D* forMarshaling);
+
+void unmarshal_VkExtent3D(
+    VulkanStream* vkStream,
+    VkExtent3D* forUnmarshaling);
+
+void marshal_VkImageFormatProperties(
+    VulkanStream* vkStream,
+    const VkImageFormatProperties* forMarshaling);
+
+void unmarshal_VkImageFormatProperties(
+    VulkanStream* vkStream,
+    VkImageFormatProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceImageFormatProperties 20005
+void marshal_VkPhysicalDeviceLimits(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceLimits* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceLimits(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceLimits* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSparseProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSparseProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSparseProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSparseProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceProperties 20006
+void marshal_VkQueueFamilyProperties(
+    VulkanStream* vkStream,
+    const VkQueueFamilyProperties* forMarshaling);
+
+void unmarshal_VkQueueFamilyProperties(
+    VulkanStream* vkStream,
+    VkQueueFamilyProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceQueueFamilyProperties 20007
+void marshal_VkMemoryType(
+    VulkanStream* vkStream,
+    const VkMemoryType* forMarshaling);
+
+void unmarshal_VkMemoryType(
+    VulkanStream* vkStream,
+    VkMemoryType* forUnmarshaling);
+
+void marshal_VkMemoryHeap(
+    VulkanStream* vkStream,
+    const VkMemoryHeap* forMarshaling);
+
+void unmarshal_VkMemoryHeap(
+    VulkanStream* vkStream,
+    VkMemoryHeap* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMemoryProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMemoryProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMemoryProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMemoryProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceMemoryProperties 20008
+#define OP_vkGetInstanceProcAddr 20009
+#define OP_vkGetDeviceProcAddr 20010
+void marshal_VkDeviceQueueCreateInfo(
+    VulkanStream* vkStream,
+    const VkDeviceQueueCreateInfo* forMarshaling);
+
+void unmarshal_VkDeviceQueueCreateInfo(
+    VulkanStream* vkStream,
+    VkDeviceQueueCreateInfo* forUnmarshaling);
+
+void marshal_VkDeviceCreateInfo(
+    VulkanStream* vkStream,
+    const VkDeviceCreateInfo* forMarshaling);
+
+void unmarshal_VkDeviceCreateInfo(
+    VulkanStream* vkStream,
+    VkDeviceCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateDevice 20011
+#define OP_vkDestroyDevice 20012
+void marshal_VkExtensionProperties(
+    VulkanStream* vkStream,
+    const VkExtensionProperties* forMarshaling);
+
+void unmarshal_VkExtensionProperties(
+    VulkanStream* vkStream,
+    VkExtensionProperties* forUnmarshaling);
+
+#define OP_vkEnumerateInstanceExtensionProperties 20013
+#define OP_vkEnumerateDeviceExtensionProperties 20014
+void marshal_VkLayerProperties(
+    VulkanStream* vkStream,
+    const VkLayerProperties* forMarshaling);
+
+void unmarshal_VkLayerProperties(
+    VulkanStream* vkStream,
+    VkLayerProperties* forUnmarshaling);
+
+#define OP_vkEnumerateInstanceLayerProperties 20015
+#define OP_vkEnumerateDeviceLayerProperties 20016
+#define OP_vkGetDeviceQueue 20017
+void marshal_VkSubmitInfo(
+    VulkanStream* vkStream,
+    const VkSubmitInfo* forMarshaling);
+
+void unmarshal_VkSubmitInfo(
+    VulkanStream* vkStream,
+    VkSubmitInfo* forUnmarshaling);
+
+#define OP_vkQueueSubmit 20018
+#define OP_vkQueueWaitIdle 20019
+#define OP_vkDeviceWaitIdle 20020
+void marshal_VkMemoryAllocateInfo(
+    VulkanStream* vkStream,
+    const VkMemoryAllocateInfo* forMarshaling);
+
+void unmarshal_VkMemoryAllocateInfo(
+    VulkanStream* vkStream,
+    VkMemoryAllocateInfo* forUnmarshaling);
+
+#define OP_vkAllocateMemory 20021
+#define OP_vkFreeMemory 20022
+#define OP_vkMapMemory 20023
+#define OP_vkUnmapMemory 20024
+void marshal_VkMappedMemoryRange(
+    VulkanStream* vkStream,
+    const VkMappedMemoryRange* forMarshaling);
+
+void unmarshal_VkMappedMemoryRange(
+    VulkanStream* vkStream,
+    VkMappedMemoryRange* forUnmarshaling);
+
+#define OP_vkFlushMappedMemoryRanges 20025
+#define OP_vkInvalidateMappedMemoryRanges 20026
+#define OP_vkGetDeviceMemoryCommitment 20027
+#define OP_vkBindBufferMemory 20028
+#define OP_vkBindImageMemory 20029
+void marshal_VkMemoryRequirements(
+    VulkanStream* vkStream,
+    const VkMemoryRequirements* forMarshaling);
+
+void unmarshal_VkMemoryRequirements(
+    VulkanStream* vkStream,
+    VkMemoryRequirements* forUnmarshaling);
+
+#define OP_vkGetBufferMemoryRequirements 20030
+#define OP_vkGetImageMemoryRequirements 20031
+void marshal_VkSparseImageFormatProperties(
+    VulkanStream* vkStream,
+    const VkSparseImageFormatProperties* forMarshaling);
+
+void unmarshal_VkSparseImageFormatProperties(
+    VulkanStream* vkStream,
+    VkSparseImageFormatProperties* forUnmarshaling);
+
+void marshal_VkSparseImageMemoryRequirements(
+    VulkanStream* vkStream,
+    const VkSparseImageMemoryRequirements* forMarshaling);
+
+void unmarshal_VkSparseImageMemoryRequirements(
+    VulkanStream* vkStream,
+    VkSparseImageMemoryRequirements* forUnmarshaling);
+
+#define OP_vkGetImageSparseMemoryRequirements 20032
+#define OP_vkGetPhysicalDeviceSparseImageFormatProperties 20033
+void marshal_VkSparseMemoryBind(
+    VulkanStream* vkStream,
+    const VkSparseMemoryBind* forMarshaling);
+
+void unmarshal_VkSparseMemoryBind(
+    VulkanStream* vkStream,
+    VkSparseMemoryBind* forUnmarshaling);
+
+void marshal_VkSparseBufferMemoryBindInfo(
+    VulkanStream* vkStream,
+    const VkSparseBufferMemoryBindInfo* forMarshaling);
+
+void unmarshal_VkSparseBufferMemoryBindInfo(
+    VulkanStream* vkStream,
+    VkSparseBufferMemoryBindInfo* forUnmarshaling);
+
+void marshal_VkSparseImageOpaqueMemoryBindInfo(
+    VulkanStream* vkStream,
+    const VkSparseImageOpaqueMemoryBindInfo* forMarshaling);
+
+void unmarshal_VkSparseImageOpaqueMemoryBindInfo(
+    VulkanStream* vkStream,
+    VkSparseImageOpaqueMemoryBindInfo* forUnmarshaling);
+
+void marshal_VkImageSubresource(
+    VulkanStream* vkStream,
+    const VkImageSubresource* forMarshaling);
+
+void unmarshal_VkImageSubresource(
+    VulkanStream* vkStream,
+    VkImageSubresource* forUnmarshaling);
+
+void marshal_VkOffset3D(
+    VulkanStream* vkStream,
+    const VkOffset3D* forMarshaling);
+
+void unmarshal_VkOffset3D(
+    VulkanStream* vkStream,
+    VkOffset3D* forUnmarshaling);
+
+void marshal_VkSparseImageMemoryBind(
+    VulkanStream* vkStream,
+    const VkSparseImageMemoryBind* forMarshaling);
+
+void unmarshal_VkSparseImageMemoryBind(
+    VulkanStream* vkStream,
+    VkSparseImageMemoryBind* forUnmarshaling);
+
+void marshal_VkSparseImageMemoryBindInfo(
+    VulkanStream* vkStream,
+    const VkSparseImageMemoryBindInfo* forMarshaling);
+
+void unmarshal_VkSparseImageMemoryBindInfo(
+    VulkanStream* vkStream,
+    VkSparseImageMemoryBindInfo* forUnmarshaling);
+
+void marshal_VkBindSparseInfo(
+    VulkanStream* vkStream,
+    const VkBindSparseInfo* forMarshaling);
+
+void unmarshal_VkBindSparseInfo(
+    VulkanStream* vkStream,
+    VkBindSparseInfo* forUnmarshaling);
+
+#define OP_vkQueueBindSparse 20034
+void marshal_VkFenceCreateInfo(
+    VulkanStream* vkStream,
+    const VkFenceCreateInfo* forMarshaling);
+
+void unmarshal_VkFenceCreateInfo(
+    VulkanStream* vkStream,
+    VkFenceCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateFence 20035
+#define OP_vkDestroyFence 20036
+#define OP_vkResetFences 20037
+#define OP_vkGetFenceStatus 20038
+#define OP_vkWaitForFences 20039
+void marshal_VkSemaphoreCreateInfo(
+    VulkanStream* vkStream,
+    const VkSemaphoreCreateInfo* forMarshaling);
+
+void unmarshal_VkSemaphoreCreateInfo(
+    VulkanStream* vkStream,
+    VkSemaphoreCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateSemaphore 20040
+#define OP_vkDestroySemaphore 20041
+void marshal_VkEventCreateInfo(
+    VulkanStream* vkStream,
+    const VkEventCreateInfo* forMarshaling);
+
+void unmarshal_VkEventCreateInfo(
+    VulkanStream* vkStream,
+    VkEventCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateEvent 20042
+#define OP_vkDestroyEvent 20043
+#define OP_vkGetEventStatus 20044
+#define OP_vkSetEvent 20045
+#define OP_vkResetEvent 20046
+void marshal_VkQueryPoolCreateInfo(
+    VulkanStream* vkStream,
+    const VkQueryPoolCreateInfo* forMarshaling);
+
+void unmarshal_VkQueryPoolCreateInfo(
+    VulkanStream* vkStream,
+    VkQueryPoolCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateQueryPool 20047
+#define OP_vkDestroyQueryPool 20048
+#define OP_vkGetQueryPoolResults 20049
+void marshal_VkBufferCreateInfo(
+    VulkanStream* vkStream,
+    const VkBufferCreateInfo* forMarshaling);
+
+void unmarshal_VkBufferCreateInfo(
+    VulkanStream* vkStream,
+    VkBufferCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateBuffer 20050
+#define OP_vkDestroyBuffer 20051
+void marshal_VkBufferViewCreateInfo(
+    VulkanStream* vkStream,
+    const VkBufferViewCreateInfo* forMarshaling);
+
+void unmarshal_VkBufferViewCreateInfo(
+    VulkanStream* vkStream,
+    VkBufferViewCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateBufferView 20052
+#define OP_vkDestroyBufferView 20053
+void marshal_VkImageCreateInfo(
+    VulkanStream* vkStream,
+    const VkImageCreateInfo* forMarshaling);
+
+void unmarshal_VkImageCreateInfo(
+    VulkanStream* vkStream,
+    VkImageCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateImage 20054
+#define OP_vkDestroyImage 20055
+void marshal_VkSubresourceLayout(
+    VulkanStream* vkStream,
+    const VkSubresourceLayout* forMarshaling);
+
+void unmarshal_VkSubresourceLayout(
+    VulkanStream* vkStream,
+    VkSubresourceLayout* forUnmarshaling);
+
+#define OP_vkGetImageSubresourceLayout 20056
+void marshal_VkComponentMapping(
+    VulkanStream* vkStream,
+    const VkComponentMapping* forMarshaling);
+
+void unmarshal_VkComponentMapping(
+    VulkanStream* vkStream,
+    VkComponentMapping* forUnmarshaling);
+
+void marshal_VkImageSubresourceRange(
+    VulkanStream* vkStream,
+    const VkImageSubresourceRange* forMarshaling);
+
+void unmarshal_VkImageSubresourceRange(
+    VulkanStream* vkStream,
+    VkImageSubresourceRange* forUnmarshaling);
+
+void marshal_VkImageViewCreateInfo(
+    VulkanStream* vkStream,
+    const VkImageViewCreateInfo* forMarshaling);
+
+void unmarshal_VkImageViewCreateInfo(
+    VulkanStream* vkStream,
+    VkImageViewCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateImageView 20057
+#define OP_vkDestroyImageView 20058
+void marshal_VkShaderModuleCreateInfo(
+    VulkanStream* vkStream,
+    const VkShaderModuleCreateInfo* forMarshaling);
+
+void unmarshal_VkShaderModuleCreateInfo(
+    VulkanStream* vkStream,
+    VkShaderModuleCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateShaderModule 20059
+#define OP_vkDestroyShaderModule 20060
+void marshal_VkPipelineCacheCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineCacheCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineCacheCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineCacheCreateInfo* forUnmarshaling);
+
+#define OP_vkCreatePipelineCache 20061
+#define OP_vkDestroyPipelineCache 20062
+#define OP_vkGetPipelineCacheData 20063
+#define OP_vkMergePipelineCaches 20064
+void marshal_VkSpecializationMapEntry(
+    VulkanStream* vkStream,
+    const VkSpecializationMapEntry* forMarshaling);
+
+void unmarshal_VkSpecializationMapEntry(
+    VulkanStream* vkStream,
+    VkSpecializationMapEntry* forUnmarshaling);
+
+void marshal_VkSpecializationInfo(
+    VulkanStream* vkStream,
+    const VkSpecializationInfo* forMarshaling);
+
+void unmarshal_VkSpecializationInfo(
+    VulkanStream* vkStream,
+    VkSpecializationInfo* forUnmarshaling);
+
+void marshal_VkPipelineShaderStageCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineShaderStageCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineShaderStageCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineShaderStageCreateInfo* forUnmarshaling);
+
+void marshal_VkVertexInputBindingDescription(
+    VulkanStream* vkStream,
+    const VkVertexInputBindingDescription* forMarshaling);
+
+void unmarshal_VkVertexInputBindingDescription(
+    VulkanStream* vkStream,
+    VkVertexInputBindingDescription* forUnmarshaling);
+
+void marshal_VkVertexInputAttributeDescription(
+    VulkanStream* vkStream,
+    const VkVertexInputAttributeDescription* forMarshaling);
+
+void unmarshal_VkVertexInputAttributeDescription(
+    VulkanStream* vkStream,
+    VkVertexInputAttributeDescription* forUnmarshaling);
+
+void marshal_VkPipelineVertexInputStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineVertexInputStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineVertexInputStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineVertexInputStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineInputAssemblyStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineInputAssemblyStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineInputAssemblyStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineTessellationStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineTessellationStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineTessellationStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineTessellationStateCreateInfo* forUnmarshaling);
+
+void marshal_VkViewport(
+    VulkanStream* vkStream,
+    const VkViewport* forMarshaling);
+
+void unmarshal_VkViewport(
+    VulkanStream* vkStream,
+    VkViewport* forUnmarshaling);
+
+void marshal_VkOffset2D(
+    VulkanStream* vkStream,
+    const VkOffset2D* forMarshaling);
+
+void unmarshal_VkOffset2D(
+    VulkanStream* vkStream,
+    VkOffset2D* forUnmarshaling);
+
+void marshal_VkExtent2D(
+    VulkanStream* vkStream,
+    const VkExtent2D* forMarshaling);
+
+void unmarshal_VkExtent2D(
+    VulkanStream* vkStream,
+    VkExtent2D* forUnmarshaling);
+
+void marshal_VkRect2D(
+    VulkanStream* vkStream,
+    const VkRect2D* forMarshaling);
+
+void unmarshal_VkRect2D(
+    VulkanStream* vkStream,
+    VkRect2D* forUnmarshaling);
+
+void marshal_VkPipelineViewportStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineViewportStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineViewportStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineViewportStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineRasterizationStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineRasterizationStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineRasterizationStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineRasterizationStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineMultisampleStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineMultisampleStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineMultisampleStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineMultisampleStateCreateInfo* forUnmarshaling);
+
+void marshal_VkStencilOpState(
+    VulkanStream* vkStream,
+    const VkStencilOpState* forMarshaling);
+
+void unmarshal_VkStencilOpState(
+    VulkanStream* vkStream,
+    VkStencilOpState* forUnmarshaling);
+
+void marshal_VkPipelineDepthStencilStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineDepthStencilStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineDepthStencilStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineDepthStencilStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineColorBlendAttachmentState(
+    VulkanStream* vkStream,
+    const VkPipelineColorBlendAttachmentState* forMarshaling);
+
+void unmarshal_VkPipelineColorBlendAttachmentState(
+    VulkanStream* vkStream,
+    VkPipelineColorBlendAttachmentState* forUnmarshaling);
+
+void marshal_VkPipelineColorBlendStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineColorBlendStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineColorBlendStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineColorBlendStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineDynamicStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineDynamicStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineDynamicStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineDynamicStateCreateInfo* forUnmarshaling);
+
+void marshal_VkGraphicsPipelineCreateInfo(
+    VulkanStream* vkStream,
+    const VkGraphicsPipelineCreateInfo* forMarshaling);
+
+void unmarshal_VkGraphicsPipelineCreateInfo(
+    VulkanStream* vkStream,
+    VkGraphicsPipelineCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateGraphicsPipelines 20065
+void marshal_VkComputePipelineCreateInfo(
+    VulkanStream* vkStream,
+    const VkComputePipelineCreateInfo* forMarshaling);
+
+void unmarshal_VkComputePipelineCreateInfo(
+    VulkanStream* vkStream,
+    VkComputePipelineCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateComputePipelines 20066
+#define OP_vkDestroyPipeline 20067
+void marshal_VkPushConstantRange(
+    VulkanStream* vkStream,
+    const VkPushConstantRange* forMarshaling);
+
+void unmarshal_VkPushConstantRange(
+    VulkanStream* vkStream,
+    VkPushConstantRange* forUnmarshaling);
+
+void marshal_VkPipelineLayoutCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineLayoutCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineLayoutCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineLayoutCreateInfo* forUnmarshaling);
+
+#define OP_vkCreatePipelineLayout 20068
+#define OP_vkDestroyPipelineLayout 20069
+void marshal_VkSamplerCreateInfo(
+    VulkanStream* vkStream,
+    const VkSamplerCreateInfo* forMarshaling);
+
+void unmarshal_VkSamplerCreateInfo(
+    VulkanStream* vkStream,
+    VkSamplerCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateSampler 20070
+#define OP_vkDestroySampler 20071
+void marshal_VkDescriptorSetLayoutBinding(
+    VulkanStream* vkStream,
+    const VkDescriptorSetLayoutBinding* forMarshaling);
+
+void unmarshal_VkDescriptorSetLayoutBinding(
+    VulkanStream* vkStream,
+    VkDescriptorSetLayoutBinding* forUnmarshaling);
+
+void marshal_VkDescriptorSetLayoutCreateInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorSetLayoutCreateInfo* forMarshaling);
+
+void unmarshal_VkDescriptorSetLayoutCreateInfo(
+    VulkanStream* vkStream,
+    VkDescriptorSetLayoutCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateDescriptorSetLayout 20072
+#define OP_vkDestroyDescriptorSetLayout 20073
+void marshal_VkDescriptorPoolSize(
+    VulkanStream* vkStream,
+    const VkDescriptorPoolSize* forMarshaling);
+
+void unmarshal_VkDescriptorPoolSize(
+    VulkanStream* vkStream,
+    VkDescriptorPoolSize* forUnmarshaling);
+
+void marshal_VkDescriptorPoolCreateInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorPoolCreateInfo* forMarshaling);
+
+void unmarshal_VkDescriptorPoolCreateInfo(
+    VulkanStream* vkStream,
+    VkDescriptorPoolCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateDescriptorPool 20074
+#define OP_vkDestroyDescriptorPool 20075
+#define OP_vkResetDescriptorPool 20076
+void marshal_VkDescriptorSetAllocateInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorSetAllocateInfo* forMarshaling);
+
+void unmarshal_VkDescriptorSetAllocateInfo(
+    VulkanStream* vkStream,
+    VkDescriptorSetAllocateInfo* forUnmarshaling);
+
+#define OP_vkAllocateDescriptorSets 20077
+#define OP_vkFreeDescriptorSets 20078
+void marshal_VkDescriptorImageInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorImageInfo* forMarshaling);
+
+void unmarshal_VkDescriptorImageInfo(
+    VulkanStream* vkStream,
+    VkDescriptorImageInfo* forUnmarshaling);
+
+void marshal_VkDescriptorBufferInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorBufferInfo* forMarshaling);
+
+void unmarshal_VkDescriptorBufferInfo(
+    VulkanStream* vkStream,
+    VkDescriptorBufferInfo* forUnmarshaling);
+
+void marshal_VkWriteDescriptorSet(
+    VulkanStream* vkStream,
+    const VkWriteDescriptorSet* forMarshaling);
+
+void unmarshal_VkWriteDescriptorSet(
+    VulkanStream* vkStream,
+    VkWriteDescriptorSet* forUnmarshaling);
+
+void marshal_VkCopyDescriptorSet(
+    VulkanStream* vkStream,
+    const VkCopyDescriptorSet* forMarshaling);
+
+void unmarshal_VkCopyDescriptorSet(
+    VulkanStream* vkStream,
+    VkCopyDescriptorSet* forUnmarshaling);
+
+#define OP_vkUpdateDescriptorSets 20079
+void marshal_VkFramebufferCreateInfo(
+    VulkanStream* vkStream,
+    const VkFramebufferCreateInfo* forMarshaling);
+
+void unmarshal_VkFramebufferCreateInfo(
+    VulkanStream* vkStream,
+    VkFramebufferCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateFramebuffer 20080
+#define OP_vkDestroyFramebuffer 20081
+void marshal_VkAttachmentDescription(
+    VulkanStream* vkStream,
+    const VkAttachmentDescription* forMarshaling);
+
+void unmarshal_VkAttachmentDescription(
+    VulkanStream* vkStream,
+    VkAttachmentDescription* forUnmarshaling);
+
+void marshal_VkAttachmentReference(
+    VulkanStream* vkStream,
+    const VkAttachmentReference* forMarshaling);
+
+void unmarshal_VkAttachmentReference(
+    VulkanStream* vkStream,
+    VkAttachmentReference* forUnmarshaling);
+
+void marshal_VkSubpassDescription(
+    VulkanStream* vkStream,
+    const VkSubpassDescription* forMarshaling);
+
+void unmarshal_VkSubpassDescription(
+    VulkanStream* vkStream,
+    VkSubpassDescription* forUnmarshaling);
+
+void marshal_VkSubpassDependency(
+    VulkanStream* vkStream,
+    const VkSubpassDependency* forMarshaling);
+
+void unmarshal_VkSubpassDependency(
+    VulkanStream* vkStream,
+    VkSubpassDependency* forUnmarshaling);
+
+void marshal_VkRenderPassCreateInfo(
+    VulkanStream* vkStream,
+    const VkRenderPassCreateInfo* forMarshaling);
+
+void unmarshal_VkRenderPassCreateInfo(
+    VulkanStream* vkStream,
+    VkRenderPassCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateRenderPass 20082
+#define OP_vkDestroyRenderPass 20083
+#define OP_vkGetRenderAreaGranularity 20084
+void marshal_VkCommandPoolCreateInfo(
+    VulkanStream* vkStream,
+    const VkCommandPoolCreateInfo* forMarshaling);
+
+void unmarshal_VkCommandPoolCreateInfo(
+    VulkanStream* vkStream,
+    VkCommandPoolCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateCommandPool 20085
+#define OP_vkDestroyCommandPool 20086
+#define OP_vkResetCommandPool 20087
+void marshal_VkCommandBufferAllocateInfo(
+    VulkanStream* vkStream,
+    const VkCommandBufferAllocateInfo* forMarshaling);
+
+void unmarshal_VkCommandBufferAllocateInfo(
+    VulkanStream* vkStream,
+    VkCommandBufferAllocateInfo* forUnmarshaling);
+
+#define OP_vkAllocateCommandBuffers 20088
+#define OP_vkFreeCommandBuffers 20089
+void marshal_VkCommandBufferInheritanceInfo(
+    VulkanStream* vkStream,
+    const VkCommandBufferInheritanceInfo* forMarshaling);
+
+void unmarshal_VkCommandBufferInheritanceInfo(
+    VulkanStream* vkStream,
+    VkCommandBufferInheritanceInfo* forUnmarshaling);
+
+void marshal_VkCommandBufferBeginInfo(
+    VulkanStream* vkStream,
+    const VkCommandBufferBeginInfo* forMarshaling);
+
+void unmarshal_VkCommandBufferBeginInfo(
+    VulkanStream* vkStream,
+    VkCommandBufferBeginInfo* forUnmarshaling);
+
+#define OP_vkBeginCommandBuffer 20090
+#define OP_vkEndCommandBuffer 20091
+#define OP_vkResetCommandBuffer 20092
+#define OP_vkCmdBindPipeline 20093
+#define OP_vkCmdSetViewport 20094
+#define OP_vkCmdSetScissor 20095
+#define OP_vkCmdSetLineWidth 20096
+#define OP_vkCmdSetDepthBias 20097
+#define OP_vkCmdSetBlendConstants 20098
+#define OP_vkCmdSetDepthBounds 20099
+#define OP_vkCmdSetStencilCompareMask 20100
+#define OP_vkCmdSetStencilWriteMask 20101
+#define OP_vkCmdSetStencilReference 20102
+#define OP_vkCmdBindDescriptorSets 20103
+#define OP_vkCmdBindIndexBuffer 20104
+#define OP_vkCmdBindVertexBuffers 20105
+#define OP_vkCmdDraw 20106
+#define OP_vkCmdDrawIndexed 20107
+#define OP_vkCmdDrawIndirect 20108
+#define OP_vkCmdDrawIndexedIndirect 20109
+#define OP_vkCmdDispatch 20110
+#define OP_vkCmdDispatchIndirect 20111
+void marshal_VkBufferCopy(
+    VulkanStream* vkStream,
+    const VkBufferCopy* forMarshaling);
+
+void unmarshal_VkBufferCopy(
+    VulkanStream* vkStream,
+    VkBufferCopy* forUnmarshaling);
+
+#define OP_vkCmdCopyBuffer 20112
+void marshal_VkImageSubresourceLayers(
+    VulkanStream* vkStream,
+    const VkImageSubresourceLayers* forMarshaling);
+
+void unmarshal_VkImageSubresourceLayers(
+    VulkanStream* vkStream,
+    VkImageSubresourceLayers* forUnmarshaling);
+
+void marshal_VkImageCopy(
+    VulkanStream* vkStream,
+    const VkImageCopy* forMarshaling);
+
+void unmarshal_VkImageCopy(
+    VulkanStream* vkStream,
+    VkImageCopy* forUnmarshaling);
+
+#define OP_vkCmdCopyImage 20113
+void marshal_VkImageBlit(
+    VulkanStream* vkStream,
+    const VkImageBlit* forMarshaling);
+
+void unmarshal_VkImageBlit(
+    VulkanStream* vkStream,
+    VkImageBlit* forUnmarshaling);
+
+#define OP_vkCmdBlitImage 20114
+void marshal_VkBufferImageCopy(
+    VulkanStream* vkStream,
+    const VkBufferImageCopy* forMarshaling);
+
+void unmarshal_VkBufferImageCopy(
+    VulkanStream* vkStream,
+    VkBufferImageCopy* forUnmarshaling);
+
+#define OP_vkCmdCopyBufferToImage 20115
+#define OP_vkCmdCopyImageToBuffer 20116
+#define OP_vkCmdUpdateBuffer 20117
+#define OP_vkCmdFillBuffer 20118
+void marshal_VkClearColorValue(
+    VulkanStream* vkStream,
+    const VkClearColorValue* forMarshaling);
+
+void unmarshal_VkClearColorValue(
+    VulkanStream* vkStream,
+    VkClearColorValue* forUnmarshaling);
+
+#define OP_vkCmdClearColorImage 20119
+void marshal_VkClearDepthStencilValue(
+    VulkanStream* vkStream,
+    const VkClearDepthStencilValue* forMarshaling);
+
+void unmarshal_VkClearDepthStencilValue(
+    VulkanStream* vkStream,
+    VkClearDepthStencilValue* forUnmarshaling);
+
+#define OP_vkCmdClearDepthStencilImage 20120
+void marshal_VkClearValue(
+    VulkanStream* vkStream,
+    const VkClearValue* forMarshaling);
+
+void unmarshal_VkClearValue(
+    VulkanStream* vkStream,
+    VkClearValue* forUnmarshaling);
+
+void marshal_VkClearAttachment(
+    VulkanStream* vkStream,
+    const VkClearAttachment* forMarshaling);
+
+void unmarshal_VkClearAttachment(
+    VulkanStream* vkStream,
+    VkClearAttachment* forUnmarshaling);
+
+void marshal_VkClearRect(
+    VulkanStream* vkStream,
+    const VkClearRect* forMarshaling);
+
+void unmarshal_VkClearRect(
+    VulkanStream* vkStream,
+    VkClearRect* forUnmarshaling);
+
+#define OP_vkCmdClearAttachments 20121
+void marshal_VkImageResolve(
+    VulkanStream* vkStream,
+    const VkImageResolve* forMarshaling);
+
+void unmarshal_VkImageResolve(
+    VulkanStream* vkStream,
+    VkImageResolve* forUnmarshaling);
+
+#define OP_vkCmdResolveImage 20122
+#define OP_vkCmdSetEvent 20123
+#define OP_vkCmdResetEvent 20124
+void marshal_VkMemoryBarrier(
+    VulkanStream* vkStream,
+    const VkMemoryBarrier* forMarshaling);
+
+void unmarshal_VkMemoryBarrier(
+    VulkanStream* vkStream,
+    VkMemoryBarrier* forUnmarshaling);
+
+void marshal_VkBufferMemoryBarrier(
+    VulkanStream* vkStream,
+    const VkBufferMemoryBarrier* forMarshaling);
+
+void unmarshal_VkBufferMemoryBarrier(
+    VulkanStream* vkStream,
+    VkBufferMemoryBarrier* forUnmarshaling);
+
+void marshal_VkImageMemoryBarrier(
+    VulkanStream* vkStream,
+    const VkImageMemoryBarrier* forMarshaling);
+
+void unmarshal_VkImageMemoryBarrier(
+    VulkanStream* vkStream,
+    VkImageMemoryBarrier* forUnmarshaling);
+
+#define OP_vkCmdWaitEvents 20125
+#define OP_vkCmdPipelineBarrier 20126
+#define OP_vkCmdBeginQuery 20127
+#define OP_vkCmdEndQuery 20128
+#define OP_vkCmdResetQueryPool 20129
+#define OP_vkCmdWriteTimestamp 20130
+#define OP_vkCmdCopyQueryPoolResults 20131
+#define OP_vkCmdPushConstants 20132
+void marshal_VkRenderPassBeginInfo(
+    VulkanStream* vkStream,
+    const VkRenderPassBeginInfo* forMarshaling);
+
+void unmarshal_VkRenderPassBeginInfo(
+    VulkanStream* vkStream,
+    VkRenderPassBeginInfo* forUnmarshaling);
+
+#define OP_vkCmdBeginRenderPass 20133
+#define OP_vkCmdNextSubpass 20134
+#define OP_vkCmdEndRenderPass 20135
+#define OP_vkCmdExecuteCommands 20136
+void marshal_VkDispatchIndirectCommand(
+    VulkanStream* vkStream,
+    const VkDispatchIndirectCommand* forMarshaling);
+
+void unmarshal_VkDispatchIndirectCommand(
+    VulkanStream* vkStream,
+    VkDispatchIndirectCommand* forUnmarshaling);
+
+void marshal_VkDrawIndexedIndirectCommand(
+    VulkanStream* vkStream,
+    const VkDrawIndexedIndirectCommand* forMarshaling);
+
+void unmarshal_VkDrawIndexedIndirectCommand(
+    VulkanStream* vkStream,
+    VkDrawIndexedIndirectCommand* forUnmarshaling);
+
+void marshal_VkDrawIndirectCommand(
+    VulkanStream* vkStream,
+    const VkDrawIndirectCommand* forMarshaling);
+
+void unmarshal_VkDrawIndirectCommand(
+    VulkanStream* vkStream,
+    VkDrawIndirectCommand* forUnmarshaling);
+
+void marshal_VkBaseOutStructure(
+    VulkanStream* vkStream,
+    const VkBaseOutStructure* forMarshaling);
+
+void unmarshal_VkBaseOutStructure(
+    VulkanStream* vkStream,
+    VkBaseOutStructure* forUnmarshaling);
+
+void marshal_VkBaseInStructure(
+    VulkanStream* vkStream,
+    const VkBaseInStructure* forMarshaling);
+
+void unmarshal_VkBaseInStructure(
+    VulkanStream* vkStream,
+    VkBaseInStructure* forUnmarshaling);
+
+#endif
+#ifdef VK_VERSION_1_1
+#define OP_vkEnumerateInstanceVersion 20137
+void marshal_VkPhysicalDeviceSubgroupProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSubgroupProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSubgroupProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSubgroupProperties* forUnmarshaling);
+
+void marshal_VkBindBufferMemoryInfo(
+    VulkanStream* vkStream,
+    const VkBindBufferMemoryInfo* forMarshaling);
+
+void unmarshal_VkBindBufferMemoryInfo(
+    VulkanStream* vkStream,
+    VkBindBufferMemoryInfo* forUnmarshaling);
+
+void marshal_VkBindImageMemoryInfo(
+    VulkanStream* vkStream,
+    const VkBindImageMemoryInfo* forMarshaling);
+
+void unmarshal_VkBindImageMemoryInfo(
+    VulkanStream* vkStream,
+    VkBindImageMemoryInfo* forUnmarshaling);
+
+#define OP_vkBindBufferMemory2 20138
+#define OP_vkBindImageMemory2 20139
+void marshal_VkPhysicalDevice16BitStorageFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDevice16BitStorageFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDevice16BitStorageFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDevice16BitStorageFeatures* forUnmarshaling);
+
+void marshal_VkMemoryDedicatedRequirements(
+    VulkanStream* vkStream,
+    const VkMemoryDedicatedRequirements* forMarshaling);
+
+void unmarshal_VkMemoryDedicatedRequirements(
+    VulkanStream* vkStream,
+    VkMemoryDedicatedRequirements* forUnmarshaling);
+
+void marshal_VkMemoryDedicatedAllocateInfo(
+    VulkanStream* vkStream,
+    const VkMemoryDedicatedAllocateInfo* forMarshaling);
+
+void unmarshal_VkMemoryDedicatedAllocateInfo(
+    VulkanStream* vkStream,
+    VkMemoryDedicatedAllocateInfo* forUnmarshaling);
+
+void marshal_VkMemoryAllocateFlagsInfo(
+    VulkanStream* vkStream,
+    const VkMemoryAllocateFlagsInfo* forMarshaling);
+
+void unmarshal_VkMemoryAllocateFlagsInfo(
+    VulkanStream* vkStream,
+    VkMemoryAllocateFlagsInfo* forUnmarshaling);
+
+void marshal_VkDeviceGroupRenderPassBeginInfo(
+    VulkanStream* vkStream,
+    const VkDeviceGroupRenderPassBeginInfo* forMarshaling);
+
+void unmarshal_VkDeviceGroupRenderPassBeginInfo(
+    VulkanStream* vkStream,
+    VkDeviceGroupRenderPassBeginInfo* forUnmarshaling);
+
+void marshal_VkDeviceGroupCommandBufferBeginInfo(
+    VulkanStream* vkStream,
+    const VkDeviceGroupCommandBufferBeginInfo* forMarshaling);
+
+void unmarshal_VkDeviceGroupCommandBufferBeginInfo(
+    VulkanStream* vkStream,
+    VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling);
+
+void marshal_VkDeviceGroupSubmitInfo(
+    VulkanStream* vkStream,
+    const VkDeviceGroupSubmitInfo* forMarshaling);
+
+void unmarshal_VkDeviceGroupSubmitInfo(
+    VulkanStream* vkStream,
+    VkDeviceGroupSubmitInfo* forUnmarshaling);
+
+void marshal_VkDeviceGroupBindSparseInfo(
+    VulkanStream* vkStream,
+    const VkDeviceGroupBindSparseInfo* forMarshaling);
+
+void unmarshal_VkDeviceGroupBindSparseInfo(
+    VulkanStream* vkStream,
+    VkDeviceGroupBindSparseInfo* forUnmarshaling);
+
+#define OP_vkGetDeviceGroupPeerMemoryFeatures 20140
+#define OP_vkCmdSetDeviceMask 20141
+#define OP_vkCmdDispatchBase 20142
+void marshal_VkBindBufferMemoryDeviceGroupInfo(
+    VulkanStream* vkStream,
+    const VkBindBufferMemoryDeviceGroupInfo* forMarshaling);
+
+void unmarshal_VkBindBufferMemoryDeviceGroupInfo(
+    VulkanStream* vkStream,
+    VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling);
+
+void marshal_VkBindImageMemoryDeviceGroupInfo(
+    VulkanStream* vkStream,
+    const VkBindImageMemoryDeviceGroupInfo* forMarshaling);
+
+void unmarshal_VkBindImageMemoryDeviceGroupInfo(
+    VulkanStream* vkStream,
+    VkBindImageMemoryDeviceGroupInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceGroupProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceGroupProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceGroupProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceGroupProperties* forUnmarshaling);
+
+void marshal_VkDeviceGroupDeviceCreateInfo(
+    VulkanStream* vkStream,
+    const VkDeviceGroupDeviceCreateInfo* forMarshaling);
+
+void unmarshal_VkDeviceGroupDeviceCreateInfo(
+    VulkanStream* vkStream,
+    VkDeviceGroupDeviceCreateInfo* forUnmarshaling);
+
+#define OP_vkEnumeratePhysicalDeviceGroups 20143
+void marshal_VkBufferMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    const VkBufferMemoryRequirementsInfo2* forMarshaling);
+
+void unmarshal_VkBufferMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    VkBufferMemoryRequirementsInfo2* forUnmarshaling);
+
+void marshal_VkImageMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    const VkImageMemoryRequirementsInfo2* forMarshaling);
+
+void unmarshal_VkImageMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    VkImageMemoryRequirementsInfo2* forUnmarshaling);
+
+void marshal_VkImageSparseMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    const VkImageSparseMemoryRequirementsInfo2* forMarshaling);
+
+void unmarshal_VkImageSparseMemoryRequirementsInfo2(
+    VulkanStream* vkStream,
+    VkImageSparseMemoryRequirementsInfo2* forUnmarshaling);
+
+void marshal_VkMemoryRequirements2(
+    VulkanStream* vkStream,
+    const VkMemoryRequirements2* forMarshaling);
+
+void unmarshal_VkMemoryRequirements2(
+    VulkanStream* vkStream,
+    VkMemoryRequirements2* forUnmarshaling);
+
+void marshal_VkSparseImageMemoryRequirements2(
+    VulkanStream* vkStream,
+    const VkSparseImageMemoryRequirements2* forMarshaling);
+
+void unmarshal_VkSparseImageMemoryRequirements2(
+    VulkanStream* vkStream,
+    VkSparseImageMemoryRequirements2* forUnmarshaling);
+
+#define OP_vkGetImageMemoryRequirements2 20144
+#define OP_vkGetBufferMemoryRequirements2 20145
+#define OP_vkGetImageSparseMemoryRequirements2 20146
+void marshal_VkPhysicalDeviceFeatures2(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceFeatures2* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceFeatures2(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceFeatures2* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceProperties2(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceProperties2* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceProperties2(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceProperties2* forUnmarshaling);
+
+void marshal_VkFormatProperties2(
+    VulkanStream* vkStream,
+    const VkFormatProperties2* forMarshaling);
+
+void unmarshal_VkFormatProperties2(
+    VulkanStream* vkStream,
+    VkFormatProperties2* forUnmarshaling);
+
+void marshal_VkImageFormatProperties2(
+    VulkanStream* vkStream,
+    const VkImageFormatProperties2* forMarshaling);
+
+void unmarshal_VkImageFormatProperties2(
+    VulkanStream* vkStream,
+    VkImageFormatProperties2* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceImageFormatInfo2(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceImageFormatInfo2* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceImageFormatInfo2(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceImageFormatInfo2* forUnmarshaling);
+
+void marshal_VkQueueFamilyProperties2(
+    VulkanStream* vkStream,
+    const VkQueueFamilyProperties2* forMarshaling);
+
+void unmarshal_VkQueueFamilyProperties2(
+    VulkanStream* vkStream,
+    VkQueueFamilyProperties2* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMemoryProperties2(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMemoryProperties2* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMemoryProperties2(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMemoryProperties2* forUnmarshaling);
+
+void marshal_VkSparseImageFormatProperties2(
+    VulkanStream* vkStream,
+    const VkSparseImageFormatProperties2* forMarshaling);
+
+void unmarshal_VkSparseImageFormatProperties2(
+    VulkanStream* vkStream,
+    VkSparseImageFormatProperties2* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSparseImageFormatInfo2(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceFeatures2 20147
+#define OP_vkGetPhysicalDeviceProperties2 20148
+#define OP_vkGetPhysicalDeviceFormatProperties2 20149
+#define OP_vkGetPhysicalDeviceImageFormatProperties2 20150
+#define OP_vkGetPhysicalDeviceQueueFamilyProperties2 20151
+#define OP_vkGetPhysicalDeviceMemoryProperties2 20152
+#define OP_vkGetPhysicalDeviceSparseImageFormatProperties2 20153
+#define OP_vkTrimCommandPool 20154
+void marshal_VkPhysicalDevicePointClippingProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDevicePointClippingProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePointClippingProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDevicePointClippingProperties* forUnmarshaling);
+
+void marshal_VkInputAttachmentAspectReference(
+    VulkanStream* vkStream,
+    const VkInputAttachmentAspectReference* forMarshaling);
+
+void unmarshal_VkInputAttachmentAspectReference(
+    VulkanStream* vkStream,
+    VkInputAttachmentAspectReference* forUnmarshaling);
+
+void marshal_VkRenderPassInputAttachmentAspectCreateInfo(
+    VulkanStream* vkStream,
+    const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling);
+
+void unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
+    VulkanStream* vkStream,
+    VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling);
+
+void marshal_VkImageViewUsageCreateInfo(
+    VulkanStream* vkStream,
+    const VkImageViewUsageCreateInfo* forMarshaling);
+
+void unmarshal_VkImageViewUsageCreateInfo(
+    VulkanStream* vkStream,
+    VkImageViewUsageCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+    VulkanStream* vkStream,
+    const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+    VulkanStream* vkStream,
+    VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling);
+
+void marshal_VkRenderPassMultiviewCreateInfo(
+    VulkanStream* vkStream,
+    const VkRenderPassMultiviewCreateInfo* forMarshaling);
+
+void unmarshal_VkRenderPassMultiviewCreateInfo(
+    VulkanStream* vkStream,
+    VkRenderPassMultiviewCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMultiviewFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMultiviewFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMultiviewFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMultiviewFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMultiviewProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMultiviewProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMultiviewProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMultiviewProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceVariablePointerFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceVariablePointerFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceVariablePointerFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceVariablePointerFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceProtectedMemoryFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceProtectedMemoryProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling);
+
+void marshal_VkDeviceQueueInfo2(
+    VulkanStream* vkStream,
+    const VkDeviceQueueInfo2* forMarshaling);
+
+void unmarshal_VkDeviceQueueInfo2(
+    VulkanStream* vkStream,
+    VkDeviceQueueInfo2* forUnmarshaling);
+
+void marshal_VkProtectedSubmitInfo(
+    VulkanStream* vkStream,
+    const VkProtectedSubmitInfo* forMarshaling);
+
+void unmarshal_VkProtectedSubmitInfo(
+    VulkanStream* vkStream,
+    VkProtectedSubmitInfo* forUnmarshaling);
+
+#define OP_vkGetDeviceQueue2 20155
+void marshal_VkSamplerYcbcrConversionCreateInfo(
+    VulkanStream* vkStream,
+    const VkSamplerYcbcrConversionCreateInfo* forMarshaling);
+
+void unmarshal_VkSamplerYcbcrConversionCreateInfo(
+    VulkanStream* vkStream,
+    VkSamplerYcbcrConversionCreateInfo* forUnmarshaling);
+
+void marshal_VkSamplerYcbcrConversionInfo(
+    VulkanStream* vkStream,
+    const VkSamplerYcbcrConversionInfo* forMarshaling);
+
+void unmarshal_VkSamplerYcbcrConversionInfo(
+    VulkanStream* vkStream,
+    VkSamplerYcbcrConversionInfo* forUnmarshaling);
+
+void marshal_VkBindImagePlaneMemoryInfo(
+    VulkanStream* vkStream,
+    const VkBindImagePlaneMemoryInfo* forMarshaling);
+
+void unmarshal_VkBindImagePlaneMemoryInfo(
+    VulkanStream* vkStream,
+    VkBindImagePlaneMemoryInfo* forUnmarshaling);
+
+void marshal_VkImagePlaneMemoryRequirementsInfo(
+    VulkanStream* vkStream,
+    const VkImagePlaneMemoryRequirementsInfo* forMarshaling);
+
+void unmarshal_VkImagePlaneMemoryRequirementsInfo(
+    VulkanStream* vkStream,
+    VkImagePlaneMemoryRequirementsInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling);
+
+void marshal_VkSamplerYcbcrConversionImageFormatProperties(
+    VulkanStream* vkStream,
+    const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling);
+
+void unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
+    VulkanStream* vkStream,
+    VkSamplerYcbcrConversionImageFormatProperties* forUnmarshaling);
+
+#define OP_vkCreateSamplerYcbcrConversion 20156
+#define OP_vkDestroySamplerYcbcrConversion 20157
+void marshal_VkDescriptorUpdateTemplateEntry(
+    VulkanStream* vkStream,
+    const VkDescriptorUpdateTemplateEntry* forMarshaling);
+
+void unmarshal_VkDescriptorUpdateTemplateEntry(
+    VulkanStream* vkStream,
+    VkDescriptorUpdateTemplateEntry* forUnmarshaling);
+
+void marshal_VkDescriptorUpdateTemplateCreateInfo(
+    VulkanStream* vkStream,
+    const VkDescriptorUpdateTemplateCreateInfo* forMarshaling);
+
+void unmarshal_VkDescriptorUpdateTemplateCreateInfo(
+    VulkanStream* vkStream,
+    VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateDescriptorUpdateTemplate 20158
+#define OP_vkDestroyDescriptorUpdateTemplate 20159
+#define OP_vkUpdateDescriptorSetWithTemplate 20160
+void marshal_VkExternalMemoryProperties(
+    VulkanStream* vkStream,
+    const VkExternalMemoryProperties* forMarshaling);
+
+void unmarshal_VkExternalMemoryProperties(
+    VulkanStream* vkStream,
+    VkExternalMemoryProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalImageFormatInfo(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling);
+
+void marshal_VkExternalImageFormatProperties(
+    VulkanStream* vkStream,
+    const VkExternalImageFormatProperties* forMarshaling);
+
+void unmarshal_VkExternalImageFormatProperties(
+    VulkanStream* vkStream,
+    VkExternalImageFormatProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalBufferInfo(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceExternalBufferInfo* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalBufferInfo(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceExternalBufferInfo* forUnmarshaling);
+
+void marshal_VkExternalBufferProperties(
+    VulkanStream* vkStream,
+    const VkExternalBufferProperties* forMarshaling);
+
+void unmarshal_VkExternalBufferProperties(
+    VulkanStream* vkStream,
+    VkExternalBufferProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceIDProperties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceIDProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceIDProperties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceIDProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceExternalBufferProperties 20161
+void marshal_VkExternalMemoryImageCreateInfo(
+    VulkanStream* vkStream,
+    const VkExternalMemoryImageCreateInfo* forMarshaling);
+
+void unmarshal_VkExternalMemoryImageCreateInfo(
+    VulkanStream* vkStream,
+    VkExternalMemoryImageCreateInfo* forUnmarshaling);
+
+void marshal_VkExternalMemoryBufferCreateInfo(
+    VulkanStream* vkStream,
+    const VkExternalMemoryBufferCreateInfo* forMarshaling);
+
+void unmarshal_VkExternalMemoryBufferCreateInfo(
+    VulkanStream* vkStream,
+    VkExternalMemoryBufferCreateInfo* forUnmarshaling);
+
+void marshal_VkExportMemoryAllocateInfo(
+    VulkanStream* vkStream,
+    const VkExportMemoryAllocateInfo* forMarshaling);
+
+void unmarshal_VkExportMemoryAllocateInfo(
+    VulkanStream* vkStream,
+    VkExportMemoryAllocateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalFenceInfo(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceExternalFenceInfo* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalFenceInfo(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceExternalFenceInfo* forUnmarshaling);
+
+void marshal_VkExternalFenceProperties(
+    VulkanStream* vkStream,
+    const VkExternalFenceProperties* forMarshaling);
+
+void unmarshal_VkExternalFenceProperties(
+    VulkanStream* vkStream,
+    VkExternalFenceProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceExternalFenceProperties 20162
+void marshal_VkExportFenceCreateInfo(
+    VulkanStream* vkStream,
+    const VkExportFenceCreateInfo* forMarshaling);
+
+void unmarshal_VkExportFenceCreateInfo(
+    VulkanStream* vkStream,
+    VkExportFenceCreateInfo* forUnmarshaling);
+
+void marshal_VkExportSemaphoreCreateInfo(
+    VulkanStream* vkStream,
+    const VkExportSemaphoreCreateInfo* forMarshaling);
+
+void unmarshal_VkExportSemaphoreCreateInfo(
+    VulkanStream* vkStream,
+    VkExportSemaphoreCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalSemaphoreInfo(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling);
+
+void marshal_VkExternalSemaphoreProperties(
+    VulkanStream* vkStream,
+    const VkExternalSemaphoreProperties* forMarshaling);
+
+void unmarshal_VkExternalSemaphoreProperties(
+    VulkanStream* vkStream,
+    VkExternalSemaphoreProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceExternalSemaphoreProperties 20163
+void marshal_VkPhysicalDeviceMaintenance3Properties(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMaintenance3Properties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMaintenance3Properties(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMaintenance3Properties* forUnmarshaling);
+
+void marshal_VkDescriptorSetLayoutSupport(
+    VulkanStream* vkStream,
+    const VkDescriptorSetLayoutSupport* forMarshaling);
+
+void unmarshal_VkDescriptorSetLayoutSupport(
+    VulkanStream* vkStream,
+    VkDescriptorSetLayoutSupport* forUnmarshaling);
+
+#define OP_vkGetDescriptorSetLayoutSupport 20164
+void marshal_VkPhysicalDeviceShaderDrawParameterFeatures(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceShaderDrawParameterFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderDrawParameterFeatures(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceShaderDrawParameterFeatures* forUnmarshaling);
+
+#endif
+#ifdef VK_KHR_surface
+#define OP_vkDestroySurfaceKHR 20165
+#define OP_vkGetPhysicalDeviceSurfaceSupportKHR 20166
+void marshal_VkSurfaceCapabilitiesKHR(
+    VulkanStream* vkStream,
+    const VkSurfaceCapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkSurfaceCapabilitiesKHR(
+    VulkanStream* vkStream,
+    VkSurfaceCapabilitiesKHR* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR 20167
+void marshal_VkSurfaceFormatKHR(
+    VulkanStream* vkStream,
+    const VkSurfaceFormatKHR* forMarshaling);
+
+void unmarshal_VkSurfaceFormatKHR(
+    VulkanStream* vkStream,
+    VkSurfaceFormatKHR* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceSurfaceFormatsKHR 20168
+#define OP_vkGetPhysicalDeviceSurfacePresentModesKHR 20169
+#endif
+#ifdef VK_KHR_swapchain
+void marshal_VkSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkSwapchainCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkSwapchainCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateSwapchainKHR 20170
+#define OP_vkDestroySwapchainKHR 20171
+#define OP_vkGetSwapchainImagesKHR 20172
+#define OP_vkAcquireNextImageKHR 20173
+void marshal_VkPresentInfoKHR(
+    VulkanStream* vkStream,
+    const VkPresentInfoKHR* forMarshaling);
+
+void unmarshal_VkPresentInfoKHR(
+    VulkanStream* vkStream,
+    VkPresentInfoKHR* forUnmarshaling);
+
+#define OP_vkQueuePresentKHR 20174
+void marshal_VkImageSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkImageSwapchainCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkImageSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkImageSwapchainCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkBindImageMemorySwapchainInfoKHR(
+    VulkanStream* vkStream,
+    const VkBindImageMemorySwapchainInfoKHR* forMarshaling);
+
+void unmarshal_VkBindImageMemorySwapchainInfoKHR(
+    VulkanStream* vkStream,
+    VkBindImageMemorySwapchainInfoKHR* forUnmarshaling);
+
+void marshal_VkAcquireNextImageInfoKHR(
+    VulkanStream* vkStream,
+    const VkAcquireNextImageInfoKHR* forMarshaling);
+
+void unmarshal_VkAcquireNextImageInfoKHR(
+    VulkanStream* vkStream,
+    VkAcquireNextImageInfoKHR* forUnmarshaling);
+
+void marshal_VkDeviceGroupPresentCapabilitiesKHR(
+    VulkanStream* vkStream,
+    const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkDeviceGroupPresentCapabilitiesKHR(
+    VulkanStream* vkStream,
+    VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling);
+
+void marshal_VkDeviceGroupPresentInfoKHR(
+    VulkanStream* vkStream,
+    const VkDeviceGroupPresentInfoKHR* forMarshaling);
+
+void unmarshal_VkDeviceGroupPresentInfoKHR(
+    VulkanStream* vkStream,
+    VkDeviceGroupPresentInfoKHR* forUnmarshaling);
+
+void marshal_VkDeviceGroupSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkGetDeviceGroupPresentCapabilitiesKHR 20175
+#define OP_vkGetDeviceGroupSurfacePresentModesKHR 20176
+#define OP_vkGetPhysicalDevicePresentRectanglesKHR 20177
+#define OP_vkAcquireNextImage2KHR 20178
+#endif
+#ifdef VK_KHR_display
+void marshal_VkDisplayPropertiesKHR(
+    VulkanStream* vkStream,
+    const VkDisplayPropertiesKHR* forMarshaling);
+
+void unmarshal_VkDisplayPropertiesKHR(
+    VulkanStream* vkStream,
+    VkDisplayPropertiesKHR* forUnmarshaling);
+
+void marshal_VkDisplayModeParametersKHR(
+    VulkanStream* vkStream,
+    const VkDisplayModeParametersKHR* forMarshaling);
+
+void unmarshal_VkDisplayModeParametersKHR(
+    VulkanStream* vkStream,
+    VkDisplayModeParametersKHR* forUnmarshaling);
+
+void marshal_VkDisplayModePropertiesKHR(
+    VulkanStream* vkStream,
+    const VkDisplayModePropertiesKHR* forMarshaling);
+
+void unmarshal_VkDisplayModePropertiesKHR(
+    VulkanStream* vkStream,
+    VkDisplayModePropertiesKHR* forUnmarshaling);
+
+void marshal_VkDisplayModeCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkDisplayModeCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkDisplayModeCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkDisplayModeCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkDisplayPlaneCapabilitiesKHR(
+    VulkanStream* vkStream,
+    const VkDisplayPlaneCapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkDisplayPlaneCapabilitiesKHR(
+    VulkanStream* vkStream,
+    VkDisplayPlaneCapabilitiesKHR* forUnmarshaling);
+
+void marshal_VkDisplayPlanePropertiesKHR(
+    VulkanStream* vkStream,
+    const VkDisplayPlanePropertiesKHR* forMarshaling);
+
+void unmarshal_VkDisplayPlanePropertiesKHR(
+    VulkanStream* vkStream,
+    VkDisplayPlanePropertiesKHR* forUnmarshaling);
+
+void marshal_VkDisplaySurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkDisplaySurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkDisplaySurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkDisplaySurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceDisplayPropertiesKHR 20179
+#define OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR 20180
+#define OP_vkGetDisplayPlaneSupportedDisplaysKHR 20181
+#define OP_vkGetDisplayModePropertiesKHR 20182
+#define OP_vkCreateDisplayModeKHR 20183
+#define OP_vkGetDisplayPlaneCapabilitiesKHR 20184
+#define OP_vkCreateDisplayPlaneSurfaceKHR 20185
+#endif
+#ifdef VK_KHR_display_swapchain
+void marshal_VkDisplayPresentInfoKHR(
+    VulkanStream* vkStream,
+    const VkDisplayPresentInfoKHR* forMarshaling);
+
+void unmarshal_VkDisplayPresentInfoKHR(
+    VulkanStream* vkStream,
+    VkDisplayPresentInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateSharedSwapchainsKHR 20186
+#endif
+#ifdef VK_KHR_xlib_surface
+void marshal_VkXlibSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkXlibSurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkXlibSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkXlibSurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateXlibSurfaceKHR 20187
+#define OP_vkGetPhysicalDeviceXlibPresentationSupportKHR 20188
+#endif
+#ifdef VK_KHR_xcb_surface
+void marshal_VkXcbSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkXcbSurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkXcbSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkXcbSurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateXcbSurfaceKHR 20189
+#define OP_vkGetPhysicalDeviceXcbPresentationSupportKHR 20190
+#endif
+#ifdef VK_KHR_wayland_surface
+void marshal_VkWaylandSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkWaylandSurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkWaylandSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkWaylandSurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateWaylandSurfaceKHR 20191
+#define OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR 20192
+#endif
+#ifdef VK_KHR_mir_surface
+void marshal_VkMirSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkMirSurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkMirSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkMirSurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateMirSurfaceKHR 20193
+#define OP_vkGetPhysicalDeviceMirPresentationSupportKHR 20194
+#endif
+#ifdef VK_KHR_android_surface
+void marshal_VkAndroidSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkAndroidSurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkAndroidSurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkAndroidSurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateAndroidSurfaceKHR 20195
+#endif
+#ifdef VK_KHR_win32_surface
+void marshal_VkWin32SurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkWin32SurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkWin32SurfaceCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkWin32SurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateWin32SurfaceKHR 20196
+#define OP_vkGetPhysicalDeviceWin32PresentationSupportKHR 20197
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#define OP_vkGetPhysicalDeviceFeatures2KHR 20198
+#define OP_vkGetPhysicalDeviceProperties2KHR 20199
+#define OP_vkGetPhysicalDeviceFormatProperties2KHR 20200
+#define OP_vkGetPhysicalDeviceImageFormatProperties2KHR 20201
+#define OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR 20202
+#define OP_vkGetPhysicalDeviceMemoryProperties2KHR 20203
+#define OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR 20204
+#endif
+#ifdef VK_KHR_device_group
+#define OP_vkGetDeviceGroupPeerMemoryFeaturesKHR 20205
+#define OP_vkCmdSetDeviceMaskKHR 20206
+#define OP_vkCmdDispatchBaseKHR 20207
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#define OP_vkTrimCommandPoolKHR 20208
+#endif
+#ifdef VK_KHR_device_group_creation
+#define OP_vkEnumeratePhysicalDeviceGroupsKHR 20209
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#define OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR 20210
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void marshal_VkImportMemoryWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportMemoryWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkImportMemoryWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkImportMemoryWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkExportMemoryWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkExportMemoryWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkExportMemoryWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkExportMemoryWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkMemoryWin32HandlePropertiesKHR(
+    VulkanStream* vkStream,
+    const VkMemoryWin32HandlePropertiesKHR* forMarshaling);
+
+void unmarshal_VkMemoryWin32HandlePropertiesKHR(
+    VulkanStream* vkStream,
+    VkMemoryWin32HandlePropertiesKHR* forUnmarshaling);
+
+void marshal_VkMemoryGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkMemoryGetWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkMemoryGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkMemoryGetWin32HandleInfoKHR* forUnmarshaling);
+
+#define OP_vkGetMemoryWin32HandleKHR 20211
+#define OP_vkGetMemoryWin32HandlePropertiesKHR 20212
+#endif
+#ifdef VK_KHR_external_memory_fd
+void marshal_VkImportMemoryFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportMemoryFdInfoKHR* forMarshaling);
+
+void unmarshal_VkImportMemoryFdInfoKHR(
+    VulkanStream* vkStream,
+    VkImportMemoryFdInfoKHR* forUnmarshaling);
+
+void marshal_VkMemoryFdPropertiesKHR(
+    VulkanStream* vkStream,
+    const VkMemoryFdPropertiesKHR* forMarshaling);
+
+void unmarshal_VkMemoryFdPropertiesKHR(
+    VulkanStream* vkStream,
+    VkMemoryFdPropertiesKHR* forUnmarshaling);
+
+void marshal_VkMemoryGetFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkMemoryGetFdInfoKHR* forMarshaling);
+
+void unmarshal_VkMemoryGetFdInfoKHR(
+    VulkanStream* vkStream,
+    VkMemoryGetFdInfoKHR* forUnmarshaling);
+
+#define OP_vkGetMemoryFdKHR 20213
+#define OP_vkGetMemoryFdPropertiesKHR 20214
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+    VulkanStream* vkStream,
+    const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling);
+
+void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+    VulkanStream* vkStream,
+    VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling);
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#define OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR 20215
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void marshal_VkImportSemaphoreWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkImportSemaphoreWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkExportSemaphoreWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkD3D12FenceSubmitInfoKHR(
+    VulkanStream* vkStream,
+    const VkD3D12FenceSubmitInfoKHR* forMarshaling);
+
+void unmarshal_VkD3D12FenceSubmitInfoKHR(
+    VulkanStream* vkStream,
+    VkD3D12FenceSubmitInfoKHR* forUnmarshaling);
+
+void marshal_VkSemaphoreGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling);
+
+#define OP_vkImportSemaphoreWin32HandleKHR 20216
+#define OP_vkGetSemaphoreWin32HandleKHR 20217
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void marshal_VkImportSemaphoreFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportSemaphoreFdInfoKHR* forMarshaling);
+
+void unmarshal_VkImportSemaphoreFdInfoKHR(
+    VulkanStream* vkStream,
+    VkImportSemaphoreFdInfoKHR* forUnmarshaling);
+
+void marshal_VkSemaphoreGetFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkSemaphoreGetFdInfoKHR* forMarshaling);
+
+void unmarshal_VkSemaphoreGetFdInfoKHR(
+    VulkanStream* vkStream,
+    VkSemaphoreGetFdInfoKHR* forUnmarshaling);
+
+#define OP_vkImportSemaphoreFdKHR 20218
+#define OP_vkGetSemaphoreFdKHR 20219
+#endif
+#ifdef VK_KHR_push_descriptor
+void marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+    VulkanStream* vkStream,
+    const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+    VulkanStream* vkStream,
+    VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling);
+
+#define OP_vkCmdPushDescriptorSetKHR 20220
+#define OP_vkCmdPushDescriptorSetWithTemplateKHR 20221
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void marshal_VkRectLayerKHR(
+    VulkanStream* vkStream,
+    const VkRectLayerKHR* forMarshaling);
+
+void unmarshal_VkRectLayerKHR(
+    VulkanStream* vkStream,
+    VkRectLayerKHR* forUnmarshaling);
+
+void marshal_VkPresentRegionKHR(
+    VulkanStream* vkStream,
+    const VkPresentRegionKHR* forMarshaling);
+
+void unmarshal_VkPresentRegionKHR(
+    VulkanStream* vkStream,
+    VkPresentRegionKHR* forUnmarshaling);
+
+void marshal_VkPresentRegionsKHR(
+    VulkanStream* vkStream,
+    const VkPresentRegionsKHR* forMarshaling);
+
+void unmarshal_VkPresentRegionsKHR(
+    VulkanStream* vkStream,
+    VkPresentRegionsKHR* forUnmarshaling);
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#define OP_vkCreateDescriptorUpdateTemplateKHR 20222
+#define OP_vkDestroyDescriptorUpdateTemplateKHR 20223
+#define OP_vkUpdateDescriptorSetWithTemplateKHR 20224
+#endif
+#ifdef VK_KHR_create_renderpass2
+void marshal_VkAttachmentDescription2KHR(
+    VulkanStream* vkStream,
+    const VkAttachmentDescription2KHR* forMarshaling);
+
+void unmarshal_VkAttachmentDescription2KHR(
+    VulkanStream* vkStream,
+    VkAttachmentDescription2KHR* forUnmarshaling);
+
+void marshal_VkAttachmentReference2KHR(
+    VulkanStream* vkStream,
+    const VkAttachmentReference2KHR* forMarshaling);
+
+void unmarshal_VkAttachmentReference2KHR(
+    VulkanStream* vkStream,
+    VkAttachmentReference2KHR* forUnmarshaling);
+
+void marshal_VkSubpassDescription2KHR(
+    VulkanStream* vkStream,
+    const VkSubpassDescription2KHR* forMarshaling);
+
+void unmarshal_VkSubpassDescription2KHR(
+    VulkanStream* vkStream,
+    VkSubpassDescription2KHR* forUnmarshaling);
+
+void marshal_VkSubpassDependency2KHR(
+    VulkanStream* vkStream,
+    const VkSubpassDependency2KHR* forMarshaling);
+
+void unmarshal_VkSubpassDependency2KHR(
+    VulkanStream* vkStream,
+    VkSubpassDependency2KHR* forUnmarshaling);
+
+void marshal_VkRenderPassCreateInfo2KHR(
+    VulkanStream* vkStream,
+    const VkRenderPassCreateInfo2KHR* forMarshaling);
+
+void unmarshal_VkRenderPassCreateInfo2KHR(
+    VulkanStream* vkStream,
+    VkRenderPassCreateInfo2KHR* forUnmarshaling);
+
+#define OP_vkCreateRenderPass2KHR 20225
+void marshal_VkSubpassBeginInfoKHR(
+    VulkanStream* vkStream,
+    const VkSubpassBeginInfoKHR* forMarshaling);
+
+void unmarshal_VkSubpassBeginInfoKHR(
+    VulkanStream* vkStream,
+    VkSubpassBeginInfoKHR* forUnmarshaling);
+
+#define OP_vkCmdBeginRenderPass2KHR 20226
+void marshal_VkSubpassEndInfoKHR(
+    VulkanStream* vkStream,
+    const VkSubpassEndInfoKHR* forMarshaling);
+
+void unmarshal_VkSubpassEndInfoKHR(
+    VulkanStream* vkStream,
+    VkSubpassEndInfoKHR* forUnmarshaling);
+
+#define OP_vkCmdNextSubpass2KHR 20227
+#define OP_vkCmdEndRenderPass2KHR 20228
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void marshal_VkSharedPresentSurfaceCapabilitiesKHR(
+    VulkanStream* vkStream,
+    const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
+    VulkanStream* vkStream,
+    VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling);
+
+#define OP_vkGetSwapchainStatusKHR 20229
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#define OP_vkGetPhysicalDeviceExternalFencePropertiesKHR 20230
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void marshal_VkImportFenceWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportFenceWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkImportFenceWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkImportFenceWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkExportFenceWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkExportFenceWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkExportFenceWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkExportFenceWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkFenceGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    const VkFenceGetWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkFenceGetWin32HandleInfoKHR(
+    VulkanStream* vkStream,
+    VkFenceGetWin32HandleInfoKHR* forUnmarshaling);
+
+#define OP_vkImportFenceWin32HandleKHR 20231
+#define OP_vkGetFenceWin32HandleKHR 20232
+#endif
+#ifdef VK_KHR_external_fence_fd
+void marshal_VkImportFenceFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkImportFenceFdInfoKHR* forMarshaling);
+
+void unmarshal_VkImportFenceFdInfoKHR(
+    VulkanStream* vkStream,
+    VkImportFenceFdInfoKHR* forUnmarshaling);
+
+void marshal_VkFenceGetFdInfoKHR(
+    VulkanStream* vkStream,
+    const VkFenceGetFdInfoKHR* forMarshaling);
+
+void unmarshal_VkFenceGetFdInfoKHR(
+    VulkanStream* vkStream,
+    VkFenceGetFdInfoKHR* forUnmarshaling);
+
+#define OP_vkImportFenceFdKHR 20233
+#define OP_vkGetFenceFdKHR 20234
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void marshal_VkPhysicalDeviceSurfaceInfo2KHR(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling);
+
+void marshal_VkSurfaceCapabilities2KHR(
+    VulkanStream* vkStream,
+    const VkSurfaceCapabilities2KHR* forMarshaling);
+
+void unmarshal_VkSurfaceCapabilities2KHR(
+    VulkanStream* vkStream,
+    VkSurfaceCapabilities2KHR* forUnmarshaling);
+
+void marshal_VkSurfaceFormat2KHR(
+    VulkanStream* vkStream,
+    const VkSurfaceFormat2KHR* forMarshaling);
+
+void unmarshal_VkSurfaceFormat2KHR(
+    VulkanStream* vkStream,
+    VkSurfaceFormat2KHR* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR 20235
+#define OP_vkGetPhysicalDeviceSurfaceFormats2KHR 20236
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void marshal_VkDisplayProperties2KHR(
+    VulkanStream* vkStream,
+    const VkDisplayProperties2KHR* forMarshaling);
+
+void unmarshal_VkDisplayProperties2KHR(
+    VulkanStream* vkStream,
+    VkDisplayProperties2KHR* forUnmarshaling);
+
+void marshal_VkDisplayPlaneProperties2KHR(
+    VulkanStream* vkStream,
+    const VkDisplayPlaneProperties2KHR* forMarshaling);
+
+void unmarshal_VkDisplayPlaneProperties2KHR(
+    VulkanStream* vkStream,
+    VkDisplayPlaneProperties2KHR* forUnmarshaling);
+
+void marshal_VkDisplayModeProperties2KHR(
+    VulkanStream* vkStream,
+    const VkDisplayModeProperties2KHR* forMarshaling);
+
+void unmarshal_VkDisplayModeProperties2KHR(
+    VulkanStream* vkStream,
+    VkDisplayModeProperties2KHR* forUnmarshaling);
+
+void marshal_VkDisplayPlaneInfo2KHR(
+    VulkanStream* vkStream,
+    const VkDisplayPlaneInfo2KHR* forMarshaling);
+
+void unmarshal_VkDisplayPlaneInfo2KHR(
+    VulkanStream* vkStream,
+    VkDisplayPlaneInfo2KHR* forUnmarshaling);
+
+void marshal_VkDisplayPlaneCapabilities2KHR(
+    VulkanStream* vkStream,
+    const VkDisplayPlaneCapabilities2KHR* forMarshaling);
+
+void unmarshal_VkDisplayPlaneCapabilities2KHR(
+    VulkanStream* vkStream,
+    VkDisplayPlaneCapabilities2KHR* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceDisplayProperties2KHR 20237
+#define OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR 20238
+#define OP_vkGetDisplayModeProperties2KHR 20239
+#define OP_vkGetDisplayPlaneCapabilities2KHR 20240
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#define OP_vkGetImageMemoryRequirements2KHR 20241
+#define OP_vkGetBufferMemoryRequirements2KHR 20242
+#define OP_vkGetImageSparseMemoryRequirements2KHR 20243
+#endif
+#ifdef VK_KHR_image_format_list
+void marshal_VkImageFormatListCreateInfoKHR(
+    VulkanStream* vkStream,
+    const VkImageFormatListCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkImageFormatListCreateInfoKHR(
+    VulkanStream* vkStream,
+    VkImageFormatListCreateInfoKHR* forUnmarshaling);
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#define OP_vkCreateSamplerYcbcrConversionKHR 20244
+#define OP_vkDestroySamplerYcbcrConversionKHR 20245
+#endif
+#ifdef VK_KHR_bind_memory2
+#define OP_vkBindBufferMemory2KHR 20246
+#define OP_vkBindImageMemory2KHR 20247
+#endif
+#ifdef VK_KHR_maintenance3
+#define OP_vkGetDescriptorSetLayoutSupportKHR 20248
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#define OP_vkCmdDrawIndirectCountKHR 20249
+#define OP_vkCmdDrawIndexedIndirectCountKHR 20250
+#endif
+#ifdef VK_KHR_8bit_storage
+void marshal_VkPhysicalDevice8BitStorageFeaturesKHR(
+    VulkanStream* vkStream,
+    const VkPhysicalDevice8BitStorageFeaturesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDevice8BitStorageFeaturesKHR(
+    VulkanStream* vkStream,
+    VkPhysicalDevice8BitStorageFeaturesKHR* forUnmarshaling);
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void marshal_VkNativeBufferANDROID(
+    VulkanStream* vkStream,
+    const VkNativeBufferANDROID* forMarshaling);
+
+void unmarshal_VkNativeBufferANDROID(
+    VulkanStream* vkStream,
+    VkNativeBufferANDROID* forUnmarshaling);
+
+#define OP_vkGetSwapchainGrallocUsageANDROID 20251
+#define OP_vkAcquireImageANDROID 20252
+#define OP_vkQueueSignalReleaseImageANDROID 20253
+#endif
+#ifdef VK_EXT_debug_report
+void marshal_VkDebugReportCallbackCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugReportCallbackCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugReportCallbackCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugReportCallbackCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkCreateDebugReportCallbackEXT 20254
+#define OP_vkDestroyDebugReportCallbackEXT 20255
+#define OP_vkDebugReportMessageEXT 20256
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+    VulkanStream* vkStream,
+    const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling);
+
+void unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+    VulkanStream* vkStream,
+    VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling);
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void marshal_VkDebugMarkerObjectNameInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugMarkerObjectNameInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugMarkerObjectNameInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugMarkerObjectNameInfoEXT* forUnmarshaling);
+
+void marshal_VkDebugMarkerObjectTagInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugMarkerObjectTagInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugMarkerObjectTagInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugMarkerObjectTagInfoEXT* forUnmarshaling);
+
+void marshal_VkDebugMarkerMarkerInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugMarkerMarkerInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugMarkerMarkerInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugMarkerMarkerInfoEXT* forUnmarshaling);
+
+#define OP_vkDebugMarkerSetObjectTagEXT 20257
+#define OP_vkDebugMarkerSetObjectNameEXT 20258
+#define OP_vkCmdDebugMarkerBeginEXT 20259
+#define OP_vkCmdDebugMarkerEndEXT 20260
+#define OP_vkCmdDebugMarkerInsertEXT 20261
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void marshal_VkDedicatedAllocationImageCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkDedicatedAllocationImageCreateInfoNV* forMarshaling);
+
+void unmarshal_VkDedicatedAllocationImageCreateInfoNV(
+    VulkanStream* vkStream,
+    VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling);
+
+void marshal_VkDedicatedAllocationBufferCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling);
+
+void unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
+    VulkanStream* vkStream,
+    VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling);
+
+void marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+    VulkanStream* vkStream,
+    const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling);
+
+void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+    VulkanStream* vkStream,
+    VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#define OP_vkCmdDrawIndirectCountAMD 20262
+#define OP_vkCmdDrawIndexedIndirectCountAMD 20263
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void marshal_VkTextureLODGatherFormatPropertiesAMD(
+    VulkanStream* vkStream,
+    const VkTextureLODGatherFormatPropertiesAMD* forMarshaling);
+
+void unmarshal_VkTextureLODGatherFormatPropertiesAMD(
+    VulkanStream* vkStream,
+    VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling);
+
+#endif
+#ifdef VK_AMD_shader_info
+void marshal_VkShaderResourceUsageAMD(
+    VulkanStream* vkStream,
+    const VkShaderResourceUsageAMD* forMarshaling);
+
+void unmarshal_VkShaderResourceUsageAMD(
+    VulkanStream* vkStream,
+    VkShaderResourceUsageAMD* forUnmarshaling);
+
+void marshal_VkShaderStatisticsInfoAMD(
+    VulkanStream* vkStream,
+    const VkShaderStatisticsInfoAMD* forMarshaling);
+
+void unmarshal_VkShaderStatisticsInfoAMD(
+    VulkanStream* vkStream,
+    VkShaderStatisticsInfoAMD* forUnmarshaling);
+
+#define OP_vkGetShaderInfoAMD 20264
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void marshal_VkExternalImageFormatPropertiesNV(
+    VulkanStream* vkStream,
+    const VkExternalImageFormatPropertiesNV* forMarshaling);
+
+void unmarshal_VkExternalImageFormatPropertiesNV(
+    VulkanStream* vkStream,
+    VkExternalImageFormatPropertiesNV* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV 20265
+#endif
+#ifdef VK_NV_external_memory
+void marshal_VkExternalMemoryImageCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkExternalMemoryImageCreateInfoNV* forMarshaling);
+
+void unmarshal_VkExternalMemoryImageCreateInfoNV(
+    VulkanStream* vkStream,
+    VkExternalMemoryImageCreateInfoNV* forUnmarshaling);
+
+void marshal_VkExportMemoryAllocateInfoNV(
+    VulkanStream* vkStream,
+    const VkExportMemoryAllocateInfoNV* forMarshaling);
+
+void unmarshal_VkExportMemoryAllocateInfoNV(
+    VulkanStream* vkStream,
+    VkExportMemoryAllocateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void marshal_VkImportMemoryWin32HandleInfoNV(
+    VulkanStream* vkStream,
+    const VkImportMemoryWin32HandleInfoNV* forMarshaling);
+
+void unmarshal_VkImportMemoryWin32HandleInfoNV(
+    VulkanStream* vkStream,
+    VkImportMemoryWin32HandleInfoNV* forUnmarshaling);
+
+void marshal_VkExportMemoryWin32HandleInfoNV(
+    VulkanStream* vkStream,
+    const VkExportMemoryWin32HandleInfoNV* forMarshaling);
+
+void unmarshal_VkExportMemoryWin32HandleInfoNV(
+    VulkanStream* vkStream,
+    VkExportMemoryWin32HandleInfoNV* forUnmarshaling);
+
+#define OP_vkGetMemoryWin32HandleNV 20266
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+    VulkanStream* vkStream,
+    const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling);
+
+void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+    VulkanStream* vkStream,
+    VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_validation_flags
+void marshal_VkValidationFlagsEXT(
+    VulkanStream* vkStream,
+    const VkValidationFlagsEXT* forMarshaling);
+
+void unmarshal_VkValidationFlagsEXT(
+    VulkanStream* vkStream,
+    VkValidationFlagsEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_NN_vi_surface
+void marshal_VkViSurfaceCreateInfoNN(
+    VulkanStream* vkStream,
+    const VkViSurfaceCreateInfoNN* forMarshaling);
+
+void unmarshal_VkViSurfaceCreateInfoNN(
+    VulkanStream* vkStream,
+    VkViSurfaceCreateInfoNN* forUnmarshaling);
+
+#define OP_vkCreateViSurfaceNN 20267
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void marshal_VkConditionalRenderingBeginInfoEXT(
+    VulkanStream* vkStream,
+    const VkConditionalRenderingBeginInfoEXT* forMarshaling);
+
+void unmarshal_VkConditionalRenderingBeginInfoEXT(
+    VulkanStream* vkStream,
+    VkConditionalRenderingBeginInfoEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling);
+
+void marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+    VulkanStream* vkStream,
+    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling);
+
+void unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+    VulkanStream* vkStream,
+    VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling);
+
+#define OP_vkCmdBeginConditionalRenderingEXT 20268
+#define OP_vkCmdEndConditionalRenderingEXT 20269
+#endif
+#ifdef VK_NVX_device_generated_commands
+void marshal_VkDeviceGeneratedCommandsFeaturesNVX(
+    VulkanStream* vkStream,
+    const VkDeviceGeneratedCommandsFeaturesNVX* forMarshaling);
+
+void unmarshal_VkDeviceGeneratedCommandsFeaturesNVX(
+    VulkanStream* vkStream,
+    VkDeviceGeneratedCommandsFeaturesNVX* forUnmarshaling);
+
+void marshal_VkDeviceGeneratedCommandsLimitsNVX(
+    VulkanStream* vkStream,
+    const VkDeviceGeneratedCommandsLimitsNVX* forMarshaling);
+
+void unmarshal_VkDeviceGeneratedCommandsLimitsNVX(
+    VulkanStream* vkStream,
+    VkDeviceGeneratedCommandsLimitsNVX* forUnmarshaling);
+
+void marshal_VkIndirectCommandsTokenNVX(
+    VulkanStream* vkStream,
+    const VkIndirectCommandsTokenNVX* forMarshaling);
+
+void unmarshal_VkIndirectCommandsTokenNVX(
+    VulkanStream* vkStream,
+    VkIndirectCommandsTokenNVX* forUnmarshaling);
+
+void marshal_VkIndirectCommandsLayoutTokenNVX(
+    VulkanStream* vkStream,
+    const VkIndirectCommandsLayoutTokenNVX* forMarshaling);
+
+void unmarshal_VkIndirectCommandsLayoutTokenNVX(
+    VulkanStream* vkStream,
+    VkIndirectCommandsLayoutTokenNVX* forUnmarshaling);
+
+void marshal_VkIndirectCommandsLayoutCreateInfoNVX(
+    VulkanStream* vkStream,
+    const VkIndirectCommandsLayoutCreateInfoNVX* forMarshaling);
+
+void unmarshal_VkIndirectCommandsLayoutCreateInfoNVX(
+    VulkanStream* vkStream,
+    VkIndirectCommandsLayoutCreateInfoNVX* forUnmarshaling);
+
+void marshal_VkCmdProcessCommandsInfoNVX(
+    VulkanStream* vkStream,
+    const VkCmdProcessCommandsInfoNVX* forMarshaling);
+
+void unmarshal_VkCmdProcessCommandsInfoNVX(
+    VulkanStream* vkStream,
+    VkCmdProcessCommandsInfoNVX* forUnmarshaling);
+
+void marshal_VkCmdReserveSpaceForCommandsInfoNVX(
+    VulkanStream* vkStream,
+    const VkCmdReserveSpaceForCommandsInfoNVX* forMarshaling);
+
+void unmarshal_VkCmdReserveSpaceForCommandsInfoNVX(
+    VulkanStream* vkStream,
+    VkCmdReserveSpaceForCommandsInfoNVX* forUnmarshaling);
+
+void marshal_VkObjectTableCreateInfoNVX(
+    VulkanStream* vkStream,
+    const VkObjectTableCreateInfoNVX* forMarshaling);
+
+void unmarshal_VkObjectTableCreateInfoNVX(
+    VulkanStream* vkStream,
+    VkObjectTableCreateInfoNVX* forUnmarshaling);
+
+void marshal_VkObjectTableEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTableEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTableEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTableEntryNVX* forUnmarshaling);
+
+void marshal_VkObjectTablePipelineEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTablePipelineEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTablePipelineEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTablePipelineEntryNVX* forUnmarshaling);
+
+void marshal_VkObjectTableDescriptorSetEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTableDescriptorSetEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTableDescriptorSetEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTableDescriptorSetEntryNVX* forUnmarshaling);
+
+void marshal_VkObjectTableVertexBufferEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTableVertexBufferEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTableVertexBufferEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTableVertexBufferEntryNVX* forUnmarshaling);
+
+void marshal_VkObjectTableIndexBufferEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTableIndexBufferEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTableIndexBufferEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTableIndexBufferEntryNVX* forUnmarshaling);
+
+void marshal_VkObjectTablePushConstantEntryNVX(
+    VulkanStream* vkStream,
+    const VkObjectTablePushConstantEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTablePushConstantEntryNVX(
+    VulkanStream* vkStream,
+    VkObjectTablePushConstantEntryNVX* forUnmarshaling);
+
+#define OP_vkCmdProcessCommandsNVX 20270
+#define OP_vkCmdReserveSpaceForCommandsNVX 20271
+#define OP_vkCreateIndirectCommandsLayoutNVX 20272
+#define OP_vkDestroyIndirectCommandsLayoutNVX 20273
+#define OP_vkCreateObjectTableNVX 20274
+#define OP_vkDestroyObjectTableNVX 20275
+#define OP_vkRegisterObjectsNVX 20276
+#define OP_vkUnregisterObjectsNVX 20277
+#define OP_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX 20278
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void marshal_VkViewportWScalingNV(
+    VulkanStream* vkStream,
+    const VkViewportWScalingNV* forMarshaling);
+
+void unmarshal_VkViewportWScalingNV(
+    VulkanStream* vkStream,
+    VkViewportWScalingNV* forUnmarshaling);
+
+void marshal_VkPipelineViewportWScalingStateCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling);
+
+void unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
+    VulkanStream* vkStream,
+    VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling);
+
+#define OP_vkCmdSetViewportWScalingNV 20279
+#endif
+#ifdef VK_EXT_direct_mode_display
+#define OP_vkReleaseDisplayEXT 20280
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#define OP_vkAcquireXlibDisplayEXT 20281
+#define OP_vkGetRandROutputDisplayEXT 20282
+#endif
+#ifdef VK_EXT_display_surface_counter
+void marshal_VkSurfaceCapabilities2EXT(
+    VulkanStream* vkStream,
+    const VkSurfaceCapabilities2EXT* forMarshaling);
+
+void unmarshal_VkSurfaceCapabilities2EXT(
+    VulkanStream* vkStream,
+    VkSurfaceCapabilities2EXT* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT 20283
+#endif
+#ifdef VK_EXT_display_control
+void marshal_VkDisplayPowerInfoEXT(
+    VulkanStream* vkStream,
+    const VkDisplayPowerInfoEXT* forMarshaling);
+
+void unmarshal_VkDisplayPowerInfoEXT(
+    VulkanStream* vkStream,
+    VkDisplayPowerInfoEXT* forUnmarshaling);
+
+void marshal_VkDeviceEventInfoEXT(
+    VulkanStream* vkStream,
+    const VkDeviceEventInfoEXT* forMarshaling);
+
+void unmarshal_VkDeviceEventInfoEXT(
+    VulkanStream* vkStream,
+    VkDeviceEventInfoEXT* forUnmarshaling);
+
+void marshal_VkDisplayEventInfoEXT(
+    VulkanStream* vkStream,
+    const VkDisplayEventInfoEXT* forMarshaling);
+
+void unmarshal_VkDisplayEventInfoEXT(
+    VulkanStream* vkStream,
+    VkDisplayEventInfoEXT* forUnmarshaling);
+
+void marshal_VkSwapchainCounterCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkSwapchainCounterCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkSwapchainCounterCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkSwapchainCounterCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkDisplayPowerControlEXT 20284
+#define OP_vkRegisterDeviceEventEXT 20285
+#define OP_vkRegisterDisplayEventEXT 20286
+#define OP_vkGetSwapchainCounterEXT 20287
+#endif
+#ifdef VK_GOOGLE_display_timing
+void marshal_VkRefreshCycleDurationGOOGLE(
+    VulkanStream* vkStream,
+    const VkRefreshCycleDurationGOOGLE* forMarshaling);
+
+void unmarshal_VkRefreshCycleDurationGOOGLE(
+    VulkanStream* vkStream,
+    VkRefreshCycleDurationGOOGLE* forUnmarshaling);
+
+void marshal_VkPastPresentationTimingGOOGLE(
+    VulkanStream* vkStream,
+    const VkPastPresentationTimingGOOGLE* forMarshaling);
+
+void unmarshal_VkPastPresentationTimingGOOGLE(
+    VulkanStream* vkStream,
+    VkPastPresentationTimingGOOGLE* forUnmarshaling);
+
+void marshal_VkPresentTimeGOOGLE(
+    VulkanStream* vkStream,
+    const VkPresentTimeGOOGLE* forMarshaling);
+
+void unmarshal_VkPresentTimeGOOGLE(
+    VulkanStream* vkStream,
+    VkPresentTimeGOOGLE* forUnmarshaling);
+
+void marshal_VkPresentTimesInfoGOOGLE(
+    VulkanStream* vkStream,
+    const VkPresentTimesInfoGOOGLE* forMarshaling);
+
+void unmarshal_VkPresentTimesInfoGOOGLE(
+    VulkanStream* vkStream,
+    VkPresentTimesInfoGOOGLE* forUnmarshaling);
+
+#define OP_vkGetRefreshCycleDurationGOOGLE 20288
+#define OP_vkGetPastPresentationTimingGOOGLE 20289
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void marshal_VkViewportSwizzleNV(
+    VulkanStream* vkStream,
+    const VkViewportSwizzleNV* forMarshaling);
+
+void unmarshal_VkViewportSwizzleNV(
+    VulkanStream* vkStream,
+    VkViewportSwizzleNV* forUnmarshaling);
+
+void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling);
+
+void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+    VulkanStream* vkStream,
+    VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling);
+
+void marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkCmdSetDiscardRectangleEXT 20290
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void marshal_VkXYColorEXT(
+    VulkanStream* vkStream,
+    const VkXYColorEXT* forMarshaling);
+
+void unmarshal_VkXYColorEXT(
+    VulkanStream* vkStream,
+    VkXYColorEXT* forUnmarshaling);
+
+void marshal_VkHdrMetadataEXT(
+    VulkanStream* vkStream,
+    const VkHdrMetadataEXT* forMarshaling);
+
+void unmarshal_VkHdrMetadataEXT(
+    VulkanStream* vkStream,
+    VkHdrMetadataEXT* forUnmarshaling);
+
+#define OP_vkSetHdrMetadataEXT 20291
+#endif
+#ifdef VK_MVK_ios_surface
+void marshal_VkIOSSurfaceCreateInfoMVK(
+    VulkanStream* vkStream,
+    const VkIOSSurfaceCreateInfoMVK* forMarshaling);
+
+void unmarshal_VkIOSSurfaceCreateInfoMVK(
+    VulkanStream* vkStream,
+    VkIOSSurfaceCreateInfoMVK* forUnmarshaling);
+
+#define OP_vkCreateIOSSurfaceMVK 20292
+#endif
+#ifdef VK_MVK_macos_surface
+void marshal_VkMacOSSurfaceCreateInfoMVK(
+    VulkanStream* vkStream,
+    const VkMacOSSurfaceCreateInfoMVK* forMarshaling);
+
+void unmarshal_VkMacOSSurfaceCreateInfoMVK(
+    VulkanStream* vkStream,
+    VkMacOSSurfaceCreateInfoMVK* forUnmarshaling);
+
+#define OP_vkCreateMacOSSurfaceMVK 20293
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void marshal_VkDebugUtilsObjectNameInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugUtilsObjectNameInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsObjectNameInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugUtilsObjectNameInfoEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsObjectTagInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugUtilsObjectTagInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsObjectTagInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugUtilsObjectTagInfoEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsLabelEXT(
+    VulkanStream* vkStream,
+    const VkDebugUtilsLabelEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsLabelEXT(
+    VulkanStream* vkStream,
+    VkDebugUtilsLabelEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsMessengerCallbackDataEXT(
+    VulkanStream* vkStream,
+    const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
+    VulkanStream* vkStream,
+    VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsMessengerCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkSetDebugUtilsObjectNameEXT 20294
+#define OP_vkSetDebugUtilsObjectTagEXT 20295
+#define OP_vkQueueBeginDebugUtilsLabelEXT 20296
+#define OP_vkQueueEndDebugUtilsLabelEXT 20297
+#define OP_vkQueueInsertDebugUtilsLabelEXT 20298
+#define OP_vkCmdBeginDebugUtilsLabelEXT 20299
+#define OP_vkCmdEndDebugUtilsLabelEXT 20300
+#define OP_vkCmdInsertDebugUtilsLabelEXT 20301
+#define OP_vkCreateDebugUtilsMessengerEXT 20302
+#define OP_vkDestroyDebugUtilsMessengerEXT 20303
+#define OP_vkSubmitDebugUtilsMessageEXT 20304
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void marshal_VkAndroidHardwareBufferUsageANDROID(
+    VulkanStream* vkStream,
+    const VkAndroidHardwareBufferUsageANDROID* forMarshaling);
+
+void unmarshal_VkAndroidHardwareBufferUsageANDROID(
+    VulkanStream* vkStream,
+    VkAndroidHardwareBufferUsageANDROID* forUnmarshaling);
+
+void marshal_VkAndroidHardwareBufferPropertiesANDROID(
+    VulkanStream* vkStream,
+    const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling);
+
+void unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
+    VulkanStream* vkStream,
+    VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling);
+
+void marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+    VulkanStream* vkStream,
+    const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling);
+
+void unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+    VulkanStream* vkStream,
+    VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling);
+
+void marshal_VkImportAndroidHardwareBufferInfoANDROID(
+    VulkanStream* vkStream,
+    const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling);
+
+void unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
+    VulkanStream* vkStream,
+    VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling);
+
+void marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+    VulkanStream* vkStream,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling);
+
+void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+    VulkanStream* vkStream,
+    VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling);
+
+void marshal_VkExternalFormatANDROID(
+    VulkanStream* vkStream,
+    const VkExternalFormatANDROID* forMarshaling);
+
+void unmarshal_VkExternalFormatANDROID(
+    VulkanStream* vkStream,
+    VkExternalFormatANDROID* forUnmarshaling);
+
+#define OP_vkGetAndroidHardwareBufferPropertiesANDROID 20305
+#define OP_vkGetMemoryAndroidHardwareBufferANDROID 20306
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void marshal_VkSamplerReductionModeCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkSamplerReductionModeCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkSamplerReductionModeCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkSamplerReductionModeCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void marshal_VkSampleLocationEXT(
+    VulkanStream* vkStream,
+    const VkSampleLocationEXT* forMarshaling);
+
+void unmarshal_VkSampleLocationEXT(
+    VulkanStream* vkStream,
+    VkSampleLocationEXT* forUnmarshaling);
+
+void marshal_VkSampleLocationsInfoEXT(
+    VulkanStream* vkStream,
+    const VkSampleLocationsInfoEXT* forMarshaling);
+
+void unmarshal_VkSampleLocationsInfoEXT(
+    VulkanStream* vkStream,
+    VkSampleLocationsInfoEXT* forUnmarshaling);
+
+void marshal_VkAttachmentSampleLocationsEXT(
+    VulkanStream* vkStream,
+    const VkAttachmentSampleLocationsEXT* forMarshaling);
+
+void unmarshal_VkAttachmentSampleLocationsEXT(
+    VulkanStream* vkStream,
+    VkAttachmentSampleLocationsEXT* forUnmarshaling);
+
+void marshal_VkSubpassSampleLocationsEXT(
+    VulkanStream* vkStream,
+    const VkSubpassSampleLocationsEXT* forMarshaling);
+
+void unmarshal_VkSubpassSampleLocationsEXT(
+    VulkanStream* vkStream,
+    VkSubpassSampleLocationsEXT* forUnmarshaling);
+
+void marshal_VkRenderPassSampleLocationsBeginInfoEXT(
+    VulkanStream* vkStream,
+    const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling);
+
+void unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
+    VulkanStream* vkStream,
+    VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling);
+
+void marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling);
+
+void marshal_VkMultisamplePropertiesEXT(
+    VulkanStream* vkStream,
+    const VkMultisamplePropertiesEXT* forMarshaling);
+
+void unmarshal_VkMultisamplePropertiesEXT(
+    VulkanStream* vkStream,
+    VkMultisamplePropertiesEXT* forUnmarshaling);
+
+#define OP_vkCmdSetSampleLocationsEXT 20307
+#define OP_vkGetPhysicalDeviceMultisamplePropertiesEXT 20308
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void marshal_VkPipelineCoverageToColorStateCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling);
+
+void unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
+    VulkanStream* vkStream,
+    VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void marshal_VkPipelineCoverageModulationStateCreateInfoNV(
+    VulkanStream* vkStream,
+    const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling);
+
+void unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
+    VulkanStream* vkStream,
+    VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void marshal_VkValidationCacheCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkValidationCacheCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkValidationCacheCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkValidationCacheCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkShaderModuleValidationCacheCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkCreateValidationCacheEXT 20309
+#define OP_vkDestroyValidationCacheEXT 20310
+#define OP_vkMergeValidationCachesEXT 20311
+#define OP_vkGetValidationCacheDataEXT 20312
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void marshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceDescriptorIndexingFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceDescriptorIndexingPropertiesEXT* forUnmarshaling);
+
+void marshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+    VulkanStream* vkStream,
+    const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* forMarshaling);
+
+void unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+    VulkanStream* vkStream,
+    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* forUnmarshaling);
+
+void marshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+    VulkanStream* vkStream,
+    const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* forMarshaling);
+
+void unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+    VulkanStream* vkStream,
+    VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void marshal_VkImportMemoryHostPointerInfoEXT(
+    VulkanStream* vkStream,
+    const VkImportMemoryHostPointerInfoEXT* forMarshaling);
+
+void unmarshal_VkImportMemoryHostPointerInfoEXT(
+    VulkanStream* vkStream,
+    VkImportMemoryHostPointerInfoEXT* forUnmarshaling);
+
+void marshal_VkMemoryHostPointerPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkMemoryHostPointerPropertiesEXT* forMarshaling);
+
+void unmarshal_VkMemoryHostPointerPropertiesEXT(
+    VulkanStream* vkStream,
+    VkMemoryHostPointerPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling);
+
+#define OP_vkGetMemoryHostPointerPropertiesEXT 20313
+#endif
+#ifdef VK_AMD_buffer_marker
+#define OP_vkCmdWriteBufferMarkerAMD 20314
+#endif
+#ifdef VK_AMD_shader_core_properties
+void marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    VulkanStream* vkStream,
+    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    VulkanStream* vkStream,
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling);
+
+void marshal_VkVertexInputBindingDivisorDescriptionEXT(
+    VulkanStream* vkStream,
+    const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling);
+
+void unmarshal_VkVertexInputBindingDivisorDescriptionEXT(
+    VulkanStream* vkStream,
+    VkVertexInputBindingDivisorDescriptionEXT* forUnmarshaling);
+
+void marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+    VulkanStream* vkStream,
+    VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void marshal_VkQueueFamilyCheckpointPropertiesNV(
+    VulkanStream* vkStream,
+    const VkQueueFamilyCheckpointPropertiesNV* forMarshaling);
+
+void unmarshal_VkQueueFamilyCheckpointPropertiesNV(
+    VulkanStream* vkStream,
+    VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling);
+
+void marshal_VkCheckpointDataNV(
+    VulkanStream* vkStream,
+    const VkCheckpointDataNV* forMarshaling);
+
+void unmarshal_VkCheckpointDataNV(
+    VulkanStream* vkStream,
+    VkCheckpointDataNV* forUnmarshaling);
+
+#define OP_vkCmdSetCheckpointNV 20315
+#define OP_vkGetQueueCheckpointDataNV 20316
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_private_defs.h b/system/vulkan_enc/goldfish_vk_private_defs.h
new file mode 100644
index 0000000..2cfdf63
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_private_defs.h
@@ -0,0 +1,90 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define VK_ANDROID_native_buffer 1
+#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER 11
+
+/* NOTE ON VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 6
+ *
+ * This version of the extension transitions from gralloc0 to gralloc1 usage
+ * flags (int -> 2x uint64_t). The WSI implementation will temporarily continue
+ * to fill out deprecated fields in VkNativeBufferANDROID, and will call the
+ * deprecated vkGetSwapchainGrallocUsageANDROID if the new
+ * vkGetSwapchainGrallocUsage2ANDROID is not supported. This transitionary
+ * backwards-compatibility support is temporary, and will likely be removed in
+ * (along with all gralloc0 support) in a future release.
+ */
+#define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION     7
+#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME   "VK_ANDROID_native_buffer"
+
+#define VK_ANDROID_NATIVE_BUFFER_ENUM(type,id)    ((type)(1000000000 + (1000 * (VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER - 1)) + (id)))
+#define VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID   VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 0)
+#define VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 1)
+#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 2)
+
+typedef enum VkSwapchainImageUsageFlagBitsANDROID {
+    VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 0x00000001,
+    VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSwapchainImageUsageFlagBitsANDROID;
+typedef VkFlags VkSwapchainImageUsageFlagsANDROID;
+
+typedef struct {
+    VkStructureType             sType; // must be VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID
+    const void*                 pNext;
+
+    // Buffer handle and stride returned from gralloc alloc()
+    const uint32_t*             handle;
+    int                         stride;
+
+    // Gralloc format and usage requested when the buffer was allocated.
+    int                         format;
+    int                         usage; // DEPRECATED in SPEC_VERSION 6
+    // -- Added in SPEC_VERSION 6 --
+    uint64_t                consumer;
+    uint64_t                producer;
+} VkNativeBufferANDROID;
+
+typedef struct {
+    VkStructureType                        sType; // must be VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID
+    const void*                            pNext;
+
+    VkSwapchainImageUsageFlagsANDROID      usage;
+} VkSwapchainImageCreateInfoANDROID;
+
+typedef struct {
+    VkStructureType                        sType; // must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID
+    const void*                            pNext;
+
+    VkBool32                               sharedImage;
+} VkPhysicalDevicePresentationPropertiesANDROID;
+
+// -- DEPRECATED in SPEC_VERSION 6 --
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
+// -- ADDED in SPEC_VERSION 6 --
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsage2ANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageANDROID)(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd);
+
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
\ No newline at end of file
diff --git a/system/vulkan_enc/vk_platform_compat.h b/system/vulkan_enc/vk_platform_compat.h
new file mode 100644
index 0000000..e182bac
--- /dev/null
+++ b/system/vulkan_enc/vk_platform_compat.h
@@ -0,0 +1,30 @@
+// Copyright (C) 2018 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.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#if VK_HEADER_VERSION < 76
+
+typedef struct VkBaseOutStructure {
+    VkStructureType               sType;
+    struct VkBaseOutStructure*    pNext;
+} VkBaseOutStructure;
+
+typedef struct VkBaseInStructure {
+    VkStructureType                    sType;
+    const struct VkBaseInStructure*    pNext;
+} VkBaseInStructure;
+
+#endif // VK_HEADER_VERSION < 76
diff --git a/tests/gles_android_wrapper/Android.mk b/tests/gles_android_wrapper/Android.mk
index d97212d..13e0cfc 100644
--- a/tests/gles_android_wrapper/Android.mk
+++ b/tests/gles_android_wrapper/Android.mk
@@ -3,7 +3,7 @@
 #### libGLESv1_CM_emul.so
 $(call emugl-begin-shared-library,libGLESv1_CM_emul)
 $(call emugl-import,libGLESv1_enc)
-$(call emugl-gen-wrapper,$(EMUGL_PATH)/system/GLESv1_enc,gl)
+$(call emugl-gen-wrapper,$(GOLDFISH_OPENGL_PATH)/system/GLESv1_enc,gl)
 $(call emugl-set-shared-library-subpath,egl)
 
 LOCAL_SRC_FILES += glesv1_emul_ifc.cpp
@@ -19,7 +19,7 @@
 #### libGLESv2_CM_emul.so
 $(call emugl-begin-shared-library, libGLESv2_emul)
 $(call emugl-import,libGLESv2_enc)
-$(call emugl-gen-wrapper,$(EMUGL_PATH)/system/GLESv2_enc,gl2)
+$(call emugl-gen-wrapper,$(GOLDFISH_OPENGL_PATH)/system/GLESv2_enc,gl2)
 LOCAL_SRC_FILES += glesv2_emul_ifc.cpp
 $(call emugl-set-shared-library-subpath,egl)
 $(call emugl-end-module)