Snap for 6686656 from ec6b3a9781723a13520e09eb59133a1ce20b0960 to sdk-releaseplatform-tools-30.0.4

Change-Id: I7785af624c216a7b54f50e7cfb6b11ef10440beb

32 files changed, 3445 insertions, 4586 deletions

diff --git a/android-emu/android/base/Pool.h b/android-emu/android/base/Pool.h
index bce2cc15..b5b1d1b9 100644
--- a/android-emu/android/base/Pool.h
+++ b/android-emu/android/base/Pool.h
@@ -36,9 +36,9 @@ public:
     //
     // Rough space cost formula:
     // O(chunksPerSize * log2(maxSize / minSize) * maxSize)
-    Pool(size_t minSize = 8,
+    Pool(size_t minSize = 4,
          size_t maxSize = 4096,
-         size_t chunksPerSize = 256);
+         size_t chunksPerSize = 1024);
 
     // All memory allocated by this pool
     // is automatically deleted when the pool
diff --git a/android-emu/android/base/ring_buffer.c b/android-emu/android/base/ring_buffer.c
index 527d2ea8..fb6845f2 100644
--- a/android-emu/android/base/ring_buffer.c
+++ b/android-emu/android/base/ring_buffer.c
@@ -407,19 +407,10 @@ long ring_buffer_view_read(
 
 void ring_buffer_yield() { }
 
-static void ring_buffer_sleep() {
-#ifdef _WIN32
-    Sleep(2);
-#else
-    usleep(2000);
-#endif
-}
-
 bool ring_buffer_wait_write(
     const struct ring_buffer* r,
     const struct ring_buffer_view* v,
-    uint32_t bytes,
-    uint64_t timeout_us) {
+    uint32_t bytes) {
 
     bool can_write =
         v ? ring_buffer_view_can_write(r, v, bytes) :
@@ -438,8 +429,7 @@ bool ring_buffer_wait_write(
 bool ring_buffer_wait_read(
     const struct ring_buffer* r,
     const struct ring_buffer_view* v,
-    uint32_t bytes,
-    uint64_t timeout_us) {
+    uint32_t bytes) {
 
     bool can_read =
         v ? ring_buffer_view_can_read(r, v, bytes) :
@@ -457,7 +447,6 @@ bool ring_buffer_wait_read(
 }
 
 static uint32_t get_step_size(
-    struct ring_buffer* r,
     struct ring_buffer_view* v,
     uint32_t bytes) {
 
@@ -491,7 +480,7 @@ uint32_t ring_buffer_write_fully_with_abort(
     uint32_t abort_value,
     const volatile uint32_t* abort_ptr) {
 
-    uint32_t candidate_step = get_step_size(r, v, bytes);
+    uint32_t candidate_step = get_step_size(v, bytes);
     uint32_t processed = 0;
 
     uint8_t* dst = (uint8_t*)data;
@@ -502,7 +491,7 @@ uint32_t ring_buffer_write_fully_with_abort(
         }
 
         long processed_here = 0;
-        ring_buffer_wait_write(r, v, candidate_step, (uint64_t)(-1));
+        ring_buffer_wait_write(r, v, candidate_step);
 
         if (v) {
             processed_here = ring_buffer_view_write(r, v, dst + processed, candidate_step, 1);
@@ -528,7 +517,7 @@ uint32_t ring_buffer_read_fully_with_abort(
     uint32_t abort_value,
     const volatile uint32_t* abort_ptr) {
 
-    uint32_t candidate_step = get_step_size(r, v, bytes);
+    uint32_t candidate_step = get_step_size(v, bytes);
     uint32_t processed = 0;
 
     uint8_t* dst = (uint8_t*)data;
@@ -540,7 +529,7 @@ uint32_t ring_buffer_read_fully_with_abort(
         }
 
         long processed_here = 0;
-        ring_buffer_wait_read(r, v, candidate_step, (uint64_t)(-1));
+        ring_buffer_wait_read(r, v, candidate_step);
 
         if (v) {
             processed_here = ring_buffer_view_read(r, v, dst + processed, candidate_step, 1);
diff --git a/android-emu/android/base/ring_buffer.h b/android-emu/android/base/ring_buffer.h
index 390a7586..7007a870 100644
--- a/android-emu/android/base/ring_buffer.h
+++ b/android-emu/android/base/ring_buffer.h
@@ -116,13 +116,11 @@ long ring_buffer_view_read(
 bool ring_buffer_wait_write(
     const struct ring_buffer* r,
     const struct ring_buffer_view* v,
-    uint32_t bytes,
-    uint64_t timeout_us);
+    uint32_t bytes);
 bool ring_buffer_wait_read(
     const struct ring_buffer* r,
     const struct ring_buffer_view* v,
-    uint32_t bytes,
-    uint64_t timeout_us);
+    uint32_t bytes);
 
 // read/write fully, blocking if there is nothing to read/write.
 void ring_buffer_write_fully(
diff --git a/fuchsia/releasepackage.py b/fuchsia/releasepackage.py
index 7f8c40ba..550070d3 100644
--- a/fuchsia/releasepackage.py
+++ b/fuchsia/releasepackage.py
@@ -41,11 +41,15 @@ if args.arch:
 else:
   arch = "x64"
 
-target_name = "%s-shared/lib.unstripped/libvulkan_goldfish.so" % arch
+target_name = "%s-shared/libvulkan_goldfish.so" % arch
 git_repo_location = "%s/third_party/goldfish-opengl" % fuchsia_root
 package_dir = "libvulkan_goldfish/%s" % arch
 package_name = "fuchsia/lib/libvulkan/%s" % package_dir
 
+debug_target_name = "%s-shared/lib.unstripped/libvulkan_goldfish.so" % arch
+debug_dir = "libvulkan_goldfish/debug-symbols-%s" % arch
+debug_package_name = "fuchsia/lib/libvulkan/%s" % debug_dir
+
 repo_name = "goldfish-opengl"
 git_branch = subprocess.check_output([
     "git", "-C", git_repo_location, "rev-parse", "--abbrev-ref", "HEAD"
@@ -83,6 +87,7 @@ if gn_output != "is_debug = false":
     print("Use --ignore-buildtype flag to upload anyway")
     sys.exit(1)
 
+# Prepare libvulkan_goldfish binaries
 file_name = "libvulkan_goldfish.so"
 full_name = os.path.join(package_dir, file_name)
 
@@ -97,6 +102,25 @@ except:
   pass
 shutil.copyfile(source_file_name, full_name)
 
+# Prepare libvulkan_goldfish debug binaries
+debug_source_file_name = os.path.join(release_dir, debug_target_name)
+elf_info = re.search(r'Build ID: ([a-f0-9]*)',
+  subprocess.check_output(['readelf', '-n', debug_source_file_name]).strip())
+if not elf_info:
+  print("Fatal: Cannot find build ID in elf binary")
+  sys.exit(1)
+
+build_id = elf_info.group(1)
+debug_output_dir = os.path.join(debug_dir, build_id[:2])
+
+try:
+  shutil.rmtree(debug_dir)
+except:
+  pass
+os.makedirs(debug_output_dir)
+shutil.copyfile(debug_source_file_name, os.path.join(debug_output_dir, build_id[2:] + '.debug'))
+
+# Create libvulkan_goldfish CIPD package
 git_rev = subprocess.check_output(
     ["git", "-C", git_repo_location, "rev-parse", "HEAD"]).strip()
 
@@ -107,8 +131,23 @@ print cipd_command
 if not args.dry_run:
   subprocess.check_call(cipd_command.split(" "))
 
+# Create libvulkan_goldfish/debug-symbols package
+cipd_command = ("%s cipd create -in %s -name %s -ref latest"
+                " -install-mode copy -tag git_revision:%s") % (
+                    fx_path, debug_dir, debug_package_name, git_rev)
+print cipd_command
+if not args.dry_run:
+  subprocess.check_call(cipd_command.split(" "))
+
+
 print ("""
   <package name="%s"
            version="git_revision:%s"
            path="prebuilt/third_party/%s"/>
 """ % (package_name, git_rev, package_dir))[1:-1]
+print ("""
+  <package name="%s"
+           version="git_revision:%s"
+           path="prebuilt/.build-id"
+           attributes="debug-symbols,debug-symbols-%s"/>
+""" % (debug_package_name, git_rev, arch))[1:-1]
diff --git a/system/OpenglSystemCommon/EmulatorFeatureInfo.h b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
index 7545e5a1..d0ae8530 100644
--- a/system/OpenglSystemCommon/EmulatorFeatureInfo.h
+++ b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
@@ -108,6 +108,12 @@ static const char kVulkanFreeMemorySync[] = "ANDROID_EMU_vulkan_free_memory_sync
 // virtio-gpu syncfd support
 static const char kVirtioGpuNativeSync[] = "ANDROID_EMU_virtio_gpu_native_sync";
 
+// Vulkan extension that required a protocol update (new marshaling structs)
+static const char kVulkanShaderFloat16Int8[] = "ANDROID_EMU_vulkan_shader_float16_int8";
+
+// Vulkan async queue submit
+static const char kVulkanAsyncQueueSubmit[] = "ANDROID_EMU_vulkan_async_queue_submit";
+
 // Struct describing available emulator features
 struct EmulatorFeatureInfo {
 
@@ -127,7 +133,9 @@ struct EmulatorFeatureInfo {
         hasVirtioGpuNext (false),
         hasSharedSlotsHostMemoryAllocator(false),
         hasVulkanFreeMemorySync(false),
-        hasVirtioGpuNativeSync(false)
+        hasVirtioGpuNativeSync(false),
+        hasVulkanShaderFloat16Int8(false),
+        hasVulkanAsyncQueueSubmit(false)
     { }
 
     SyncImpl syncImpl;
@@ -146,6 +154,8 @@ struct EmulatorFeatureInfo {
     bool hasSharedSlotsHostMemoryAllocator;
     bool hasVulkanFreeMemorySync;
     bool hasVirtioGpuNativeSync;
+    bool hasVulkanShaderFloat16Int8;
+    bool hasVulkanAsyncQueueSubmit;
 };
 
 enum HostConnectionType {
diff --git a/system/OpenglSystemCommon/HostConnection.cpp b/system/OpenglSystemCommon/HostConnection.cpp
index 8ab05eaa..c371742e 100644
--- a/system/OpenglSystemCommon/HostConnection.cpp
+++ b/system/OpenglSystemCommon/HostConnection.cpp
@@ -352,11 +352,6 @@ 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(),
     m_grallocOnly(true),
@@ -369,15 +364,11 @@ HostConnection::~HostConnection()
     // round-trip to ensure that queued commands have been processed
     // before process pipe closure is detected.
     if (m_rcEnc) {
-        (void) m_rcEnc->rcGetRendererVersion(m_rcEnc);
+        (void)m_rcEnc->rcGetRendererVersion(m_rcEnc.get());
     }
     if (m_grallocType == GRALLOC_TYPE_MINIGBM) {
         delete m_grallocHelper;
     }
-    delete m_stream;
-    delete m_glEnc;
-    delete m_gl2Enc;
-    delete m_rcEnc;
 
     if (m_rendernodeFdOwned) {
         close(m_rendernodeFd);
@@ -385,43 +376,40 @@ HostConnection::~HostConnection()
 }
 
 // static
-HostConnection* HostConnection::connect(HostConnection* con) {
-    if (!con) return con;
-
+std::unique_ptr<HostConnection> HostConnection::connect() {
     const enum HostConnectionType connType = getConnectionTypeFromProperty();
     // const enum HostConnectionType connType = HOST_CONNECTION_VIRTIO_GPU;
 
+    // Use "new" to access a non-public constructor.
+    auto con = std::unique_ptr<HostConnection>(new HostConnection);
     switch (connType) {
         case HOST_CONNECTION_ADDRESS_SPACE: {
-            AddressSpaceStream *stream = createAddressSpaceStream(STREAM_BUFFER_SIZE);
+            auto stream = std::unique_ptr<AddressSpaceStream>(
+                createAddressSpaceStream(STREAM_BUFFER_SIZE));
             if (!stream) {
                 ALOGE("Failed to create AddressSpaceStream for host connection!!!\n");
-                delete con;
-                return NULL;
+                return nullptr;
             }
             con->m_connectionType = HOST_CONNECTION_ADDRESS_SPACE;
             con->m_grallocType = GRALLOC_TYPE_RANCHU;
-            con->m_stream = stream;
+            con->m_stream = std::move(stream);
             con->m_grallocHelper = &m_goldfishGralloc;
             con->m_processPipe = &m_goldfishProcessPipe;
             break;
         }
         case HOST_CONNECTION_QEMU_PIPE: {
-            QemuPipeStream *stream = new QemuPipeStream(STREAM_BUFFER_SIZE);
+            auto stream = std::make_unique<QemuPipeStream>(STREAM_BUFFER_SIZE);
             if (!stream) {
                 ALOGE("Failed to create QemuPipeStream for host connection!!!\n");
-                delete con;
-                return NULL;
+                return nullptr;
             }
             if (stream->connect() < 0) {
                 ALOGE("Failed to connect to host (QemuPipeStream)!!!\n");
-                delete stream;
-                delete con;
-                return NULL;
+                return nullptr;
             }
             con->m_connectionType = HOST_CONNECTION_QEMU_PIPE;
             con->m_grallocType = GRALLOC_TYPE_RANCHU;
-            con->m_stream = stream;
+            con->m_stream = std::move(stream);
             con->m_grallocHelper = &m_goldfishGralloc;
             con->m_processPipe = &m_goldfishProcessPipe;
             break;
@@ -429,26 +417,22 @@ HostConnection* HostConnection::connect(HostConnection* con) {
         case HOST_CONNECTION_TCP: {
 #ifdef __Fuchsia__
             ALOGE("Fuchsia doesn't support HOST_CONNECTION_TCP!!!\n");
-            delete con;
-            return NULL;
+            return nullptr;
             break;
 #else
-            TcpStream *stream = new TcpStream(STREAM_BUFFER_SIZE);
+            auto stream = std::make_unique<TcpStream>(STREAM_BUFFER_SIZE);
             if (!stream) {
                 ALOGE("Failed to create TcpStream for host connection!!!\n");
-                delete con;
-                return NULL;
+                return nullptr;
             }
 
             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;
+                return nullptr;
             }
             con->m_connectionType = HOST_CONNECTION_TCP;
             con->m_grallocType = GRALLOC_TYPE_RANCHU;
-            con->m_stream = stream;
+            con->m_stream = std::move(stream);
             con->m_grallocHelper = &m_goldfishGralloc;
             con->m_processPipe = &m_goldfishProcessPipe;
             break;
@@ -456,54 +440,51 @@ HostConnection* HostConnection::connect(HostConnection* con) {
         }
 #ifdef VIRTIO_GPU
         case HOST_CONNECTION_VIRTIO_GPU: {
-            VirtioGpuStream *stream = new VirtioGpuStream(STREAM_BUFFER_SIZE);
+            auto stream = std::make_unique<VirtioGpuStream>(STREAM_BUFFER_SIZE);
             if (!stream) {
                 ALOGE("Failed to create VirtioGpu for host connection!!!\n");
-                delete con;
-                return NULL;
+                return nullptr;
             }
             if (stream->connect() < 0) {
                 ALOGE("Failed to connect to host (VirtioGpu)!!!\n");
-                delete stream;
-                delete con;
-                return NULL;
+                return nullptr;
             }
             con->m_connectionType = HOST_CONNECTION_VIRTIO_GPU;
             con->m_grallocType = GRALLOC_TYPE_MINIGBM;
-            con->m_stream = stream;
+            auto rendernodeFd = stream->getRendernodeFd();
+            con->m_processPipe = stream->getProcessPipe();
+            con->m_stream = std::move(stream);
             con->m_rendernodeFdOwned = false;
-            con->m_rendernodeFdOwned = stream->getRendernodeFd();
+            con->m_rendernodeFdOwned = rendernodeFd;
             MinigbmGralloc* m = new MinigbmGralloc;
-            m->setFd(stream->getRendernodeFd());
+            m->setFd(rendernodeFd);
             con->m_grallocHelper = m;
-            con->m_processPipe = stream->getProcessPipe();
             break;
         }
         case HOST_CONNECTION_VIRTIO_GPU_PIPE: {
-            VirtioGpuPipeStream *stream = new VirtioGpuPipeStream(STREAM_BUFFER_SIZE);
+            auto stream =
+                std::make_unique<VirtioGpuPipeStream>(STREAM_BUFFER_SIZE);
             if (!stream) {
                 ALOGE("Failed to create VirtioGpu for host connection!!!\n");
-                delete con;
-                return NULL;
+                return nullptr;
             }
             if (stream->connect() < 0) {
                 ALOGE("Failed to connect to host (VirtioGpu)!!!\n");
-                delete stream;
-                delete con;
-                return NULL;
+                return nullptr;
             }
             con->m_connectionType = HOST_CONNECTION_VIRTIO_GPU_PIPE;
             con->m_grallocType = getGrallocTypeFromProperty();
-            con->m_stream = stream;
             con->m_rendernodeFdOwned = false;
-            con->m_rendernodeFd = stream->getRendernodeFd();
+            auto rendernodeFd = stream->getRendernodeFd();
+            con->m_stream = std::move(stream);
+            con->m_rendernodeFd = rendernodeFd;
             switch (con->m_grallocType) {
                 case GRALLOC_TYPE_RANCHU:
                     con->m_grallocHelper = &m_goldfishGralloc;
                     break;
                 case GRALLOC_TYPE_MINIGBM: {
                     MinigbmGralloc* m = new MinigbmGralloc;
-                    m->setFd(stream->getRendernodeFd());
+                    m->setFd(rendernodeFd);
                     con->m_grallocHelper = m;
                     break;
                 }
@@ -516,24 +497,25 @@ HostConnection* HostConnection::connect(HostConnection* con) {
         }
 #ifndef HOST_BUILD
         case HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE: {
-            AddressSpaceStream *stream = createVirtioGpuAddressSpaceStream(STREAM_BUFFER_SIZE);
+            auto stream = std::unique_ptr<AddressSpaceStream>(
+                createVirtioGpuAddressSpaceStream(STREAM_BUFFER_SIZE));
             if (!stream) {
                 ALOGE("Failed to create virtgpu AddressSpaceStream for host connection!!!\n");
-                delete con;
-                return NULL;
+                return nullptr;
             }
             con->m_connectionType = HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE;
             con->m_grallocType = getGrallocTypeFromProperty();
-            con->m_stream = stream;
             con->m_rendernodeFdOwned = false;
-            con->m_rendernodeFd = stream->getRendernodeFd();
+            auto rendernodeFd = stream->getRendernodeFd();
+            con->m_stream = std::move(stream);
+            con->m_rendernodeFd = rendernodeFd;
             switch (con->m_grallocType) {
                 case GRALLOC_TYPE_RANCHU:
                     con->m_grallocHelper = &m_goldfishGralloc;
                     break;
                 case GRALLOC_TYPE_MINIGBM: {
                     MinigbmGralloc* m = new MinigbmGralloc;
-                    m->setFd(stream->getRendernodeFd());
+                    m->setFd(rendernodeFd);
                     con->m_grallocHelper = m;
                     break;
                 }
@@ -558,7 +540,7 @@ HostConnection* HostConnection::connect(HostConnection* con) {
     con->m_stream->commitBuffer(sizeof(unsigned int));
 
     ALOGD("HostConnection::get() New Host Connection established %p, tid %d\n",
-          con, getCurrentThreadId());
+          con.get(), getCurrentThreadId());
 
     // ALOGD("Address space echo latency check done\n");
     return con;
@@ -575,13 +557,10 @@ HostConnection *HostConnection::getWithThreadInfo(EGLThreadInfo* tinfo) {
     }
 
     if (tinfo->hostConn == NULL) {
-        HostConnection *con = new HostConnection();
-        con = connect(con);
-
-        tinfo->hostConn = con;
+        tinfo->hostConn = HostConnection::createUnique();
     }
 
-    return tinfo->hostConn;
+    return tinfo->hostConn.get();
 }
 
 void HostConnection::exit() {
@@ -590,38 +569,31 @@ void HostConnection::exit() {
         return;
     }
 
-    if (tinfo->hostConn) {
-        delete tinfo->hostConn;
-        tinfo->hostConn = NULL;
-    }
+    tinfo->hostConn.reset();
 }
 
 // static
-HostConnection *HostConnection::createUnique() {
+std::unique_ptr<HostConnection> HostConnection::createUnique() {
     ALOGD("%s: call\n", __func__);
-    return connect(new HostConnection());
-}
-
-// static
-void HostConnection::teardownUnique(HostConnection* con) {
-    delete con;
+    return connect();
 }
 
 GLEncoder *HostConnection::glEncoder()
 {
     if (!m_glEnc) {
-        m_glEnc = new GLEncoder(m_stream, checksumHelper());
+        m_glEnc = std::make_unique<GLEncoder>(m_stream.get(), checksumHelper());
         DBG("HostConnection::glEncoder new encoder %p, tid %d",
             m_glEnc, getCurrentThreadId());
         m_glEnc->setContextAccessor(s_getGLContext);
     }
-    return m_glEnc;
+    return m_glEnc.get();
 }
 
 GL2Encoder *HostConnection::gl2Encoder()
 {
     if (!m_gl2Enc) {
-        m_gl2Enc = new GL2Encoder(m_stream, checksumHelper());
+        m_gl2Enc =
+            std::make_unique<GL2Encoder>(m_stream.get(), checksumHelper());
         DBG("HostConnection::gl2Encoder new encoder %p, tid %d",
             m_gl2Enc, getCurrentThreadId());
         m_gl2Enc->setContextAccessor(s_getGL2Context);
@@ -630,44 +602,49 @@ GL2Encoder *HostConnection::gl2Encoder()
             getDrawCallFlushIntervalFromProperty());
         m_gl2Enc->setHasAsyncUnmapBuffer(m_rcEnc->hasAsyncUnmapBuffer());
     }
-    return m_gl2Enc;
+    return m_gl2Enc.get();
 }
 
 VkEncoder *HostConnection::vkEncoder()
 {
     if (!m_vkEnc) {
-        m_vkEnc = new VkEncoder(m_stream);
+        m_vkEnc = std::make_unique<VkEncoder>(m_stream.get());
     }
-    return m_vkEnc;
+    return m_vkEnc.get();
 }
 
 ExtendedRCEncoderContext *HostConnection::rcEncoder()
 {
     if (!m_rcEnc) {
-        m_rcEnc = new ExtendedRCEncoderContext(m_stream, checksumHelper());
-        setChecksumHelper(m_rcEnc);
-        queryAndSetSyncImpl(m_rcEnc);
-        queryAndSetDmaImpl(m_rcEnc);
-        queryAndSetGLESMaxVersion(m_rcEnc);
-        queryAndSetNoErrorState(m_rcEnc);
-        queryAndSetHostCompositionImpl(m_rcEnc);
-        queryAndSetDirectMemSupport(m_rcEnc);
-        queryAndSetVulkanSupport(m_rcEnc);
-        queryAndSetDeferredVulkanCommandsSupport(m_rcEnc);
-        queryAndSetVulkanNullOptionalStringsSupport(m_rcEnc);
-        queryAndSetVulkanCreateResourcesWithRequirementsSupport(m_rcEnc);
-        queryAndSetVulkanIgnoredHandles(m_rcEnc);
-        queryAndSetYUVCache(m_rcEnc);
-        queryAndSetAsyncUnmapBuffer(m_rcEnc);
-        queryAndSetVirtioGpuNext(m_rcEnc);
-        queryHasSharedSlotsHostMemoryAllocator(m_rcEnc);
-        queryAndSetVulkanFreeMemorySync(m_rcEnc);
-        queryAndSetVirtioGpuNativeSync(m_rcEnc);
+        m_rcEnc = std::make_unique<ExtendedRCEncoderContext>(m_stream.get(),
+                                                             checksumHelper());
+
+        ExtendedRCEncoderContext* rcEnc = m_rcEnc.get();
+        setChecksumHelper(rcEnc);
+        queryAndSetSyncImpl(rcEnc);
+        queryAndSetDmaImpl(rcEnc);
+        queryAndSetGLESMaxVersion(rcEnc);
+        queryAndSetNoErrorState(rcEnc);
+        queryAndSetHostCompositionImpl(rcEnc);
+        queryAndSetDirectMemSupport(rcEnc);
+        queryAndSetVulkanSupport(rcEnc);
+        queryAndSetDeferredVulkanCommandsSupport(rcEnc);
+        queryAndSetVulkanNullOptionalStringsSupport(rcEnc);
+        queryAndSetVulkanCreateResourcesWithRequirementsSupport(rcEnc);
+        queryAndSetVulkanIgnoredHandles(rcEnc);
+        queryAndSetYUVCache(rcEnc);
+        queryAndSetAsyncUnmapBuffer(rcEnc);
+        queryAndSetVirtioGpuNext(rcEnc);
+        queryHasSharedSlotsHostMemoryAllocator(rcEnc);
+        queryAndSetVulkanFreeMemorySync(rcEnc);
+        queryAndSetVirtioGpuNativeSync(rcEnc);
+        queryAndSetVulkanShaderFloat16Int8Support(rcEnc);
+        queryAndSetVulkanAsyncQueueSubmitSupport(rcEnc);
         if (m_processPipe) {
-            m_processPipe->processPipeInit(m_connectionType, m_rcEnc);
+            m_processPipe->processPipeInit(m_connectionType, rcEnc);
         }
     }
-    return m_rcEnc;
+    return m_rcEnc.get();
 }
 
 int HostConnection::getOrCreateRendernodeFd() {
@@ -698,7 +675,7 @@ gl_client_context_t *HostConnection::s_getGLContext()
 {
     EGLThreadInfo *ti = getEGLThreadInfo();
     if (ti->hostConn) {
-        return ti->hostConn->m_glEnc;
+        return ti->hostConn->m_glEnc.get();
     }
     return NULL;
 }
@@ -707,7 +684,7 @@ gl2_client_context_t *HostConnection::s_getGL2Context()
 {
     EGLThreadInfo *ti = getEGLThreadInfo();
     if (ti->hostConn) {
-        return ti->hostConn->m_gl2Enc;
+        return ti->hostConn->m_gl2Enc.get();
     }
     return NULL;
 }
@@ -912,3 +889,16 @@ void HostConnection::queryAndSetVirtioGpuNativeSync(ExtendedRCEncoderContext* rc
     }
 }
 
+void HostConnection::queryAndSetVulkanShaderFloat16Int8Support(ExtendedRCEncoderContext* rcEnc) {
+    std::string glExtensions = queryGLExtensions(rcEnc);
+    if (glExtensions.find(kVulkanShaderFloat16Int8) != std::string::npos) {
+        rcEnc->featureInfo()->hasVulkanShaderFloat16Int8 = true;
+    }
+}
+
+void HostConnection::queryAndSetVulkanAsyncQueueSubmitSupport(ExtendedRCEncoderContext* rcEnc) {
+    std::string glExtensions = queryGLExtensions(rcEnc);
+    if (glExtensions.find(kVulkanAsyncQueueSubmit) != std::string::npos) {
+        rcEnc->featureInfo()->hasVulkanAsyncQueueSubmit = true;
+    }
+}
diff --git a/system/OpenglSystemCommon/HostConnection.h b/system/OpenglSystemCommon/HostConnection.h
index 6acefee3..69d8a16b 100644
--- a/system/OpenglSystemCommon/HostConnection.h
+++ b/system/OpenglSystemCommon/HostConnection.h
@@ -30,6 +30,7 @@
 #include <utils/threads.h>
 #endif
 
+#include <memory>
 #include <string>
 
 class GLEncoder;
@@ -140,8 +141,8 @@ public:
     static HostConnection *getWithThreadInfo(EGLThreadInfo* tInfo);
     static void exit();
 
-    static HostConnection *createUnique();
-    static void teardownUnique(HostConnection* con);
+    static std::unique_ptr<HostConnection> createUnique();
+    HostConnection(const HostConnection&) = delete;
 
     ~HostConnection();
 
@@ -187,7 +188,7 @@ public:
 private:
     // If the connection failed, |conn| is deleted.
     // Returns NULL if connection failed.
-    static HostConnection* connect(HostConnection* con);
+    static std::unique_ptr<HostConnection> connect();
 
     HostConnection();
     static gl_client_context_t  *s_getGLContext();
@@ -214,18 +215,22 @@ private:
     void queryHasSharedSlotsHostMemoryAllocator(ExtendedRCEncoderContext *rcEnc);
     void queryAndSetVulkanFreeMemorySync(ExtendedRCEncoderContext *rcEnc);
     void queryAndSetVirtioGpuNativeSync(ExtendedRCEncoderContext *rcEnc);
+    void queryAndSetVulkanShaderFloat16Int8Support(ExtendedRCEncoderContext *rcEnc);
+    void queryAndSetVulkanAsyncQueueSubmitSupport(ExtendedRCEncoderContext *rcEnc);
 
 private:
     HostConnectionType m_connectionType;
     GrallocType m_grallocType;
-    IOStream *m_stream;
-    GLEncoder   *m_glEnc;
-    GL2Encoder  *m_gl2Enc;
-    goldfish_vk::VkEncoder  *m_vkEnc;
-    ExtendedRCEncoderContext *m_rcEnc;
+
+    std::unique_ptr<IOStream> m_stream;
+    std::unique_ptr<GLEncoder> m_glEnc;
+    std::unique_ptr<GL2Encoder> m_gl2Enc;
+    std::unique_ptr<goldfish_vk::VkEncoder> m_vkEnc;
+    std::unique_ptr<ExtendedRCEncoderContext> m_rcEnc;
+
     ChecksumCalculator m_checksumHelper;
-    Gralloc *m_grallocHelper;
-    ProcessPipe *m_processPipe;
+    Gralloc* m_grallocHelper = nullptr;
+    ProcessPipe* m_processPipe = nullptr;
     std::string m_glExtensions;
     bool m_grallocOnly;
     bool m_noHostError;
diff --git a/system/OpenglSystemCommon/ThreadInfo.cpp b/system/OpenglSystemCommon/ThreadInfo.cpp
index fea6cb73..99b0b9b5 100644
--- a/system/OpenglSystemCommon/ThreadInfo.cpp
+++ b/system/OpenglSystemCommon/ThreadInfo.cpp
@@ -45,7 +45,6 @@ static void tlsDestruct(void *ptr)
 #endif
         ) {
         EGLThreadInfo *ti = (EGLThreadInfo *)ptr;
-        delete ti->hostConn;
         delete ti;
 #ifdef __ANDROID__
         ((void **)__get_tls())[TLS_SLOT_OPENGL] = NULL;
diff --git a/system/OpenglSystemCommon/ThreadInfo.h b/system/OpenglSystemCommon/ThreadInfo.h
index 7d2260a2..fa6b44bc 100644
--- a/system/OpenglSystemCommon/ThreadInfo.h
+++ b/system/OpenglSystemCommon/ThreadInfo.h
@@ -24,10 +24,10 @@ struct EGLContext_t;
 
 struct EGLThreadInfo
 {
-    EGLThreadInfo() : currentContext(NULL), hostConn(NULL), eglError(EGL_SUCCESS) { }
+    EGLThreadInfo() : currentContext(NULL), eglError(EGL_SUCCESS) {}
 
     EGLContext_t *currentContext;
-    HostConnection *hostConn;
+    std::unique_ptr<HostConnection> hostConn;
     int           eglError;
 };
 
diff --git a/system/OpenglSystemCommon/VirtioGpuStream.cpp b/system/OpenglSystemCommon/VirtioGpuStream.cpp
index a0876dca..1b49244c 100644
--- a/system/OpenglSystemCommon/VirtioGpuStream.cpp
+++ b/system/OpenglSystemCommon/VirtioGpuStream.cpp
@@ -282,7 +282,7 @@ int VirtioGpuStream::writeFully(const void *buf, size_t len)
 
     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",
+            "cmd_pos=%zu, flush_pos=%zu, cmdsize=%" PRIu32 ", lethal error, exiting",
             __func__, len, m_cmdPos, m_flushPos, cmd->cmdSize);
         abort();
     }
@@ -344,7 +344,7 @@ const unsigned char *VirtioGpuStream::readFully(void *buf, size_t len)
 
     // 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 "
+        ERR("%s: failed, op %" PRIu32 ", len %zu, cmdSize %" PRIu32 ", pos %zu, lethal "
             "error, exiting.", __func__, m_cmdResp->op, len,
             m_cmdResp->cmdSize, m_cmdRespPos);
         abort();
@@ -380,7 +380,7 @@ int VirtioGpuStream::commitAll()
 
         // Should never happen
         if (pos + cmd->cmdSize > m_bufSize) {
-            ERR("%s: failed, pos %zu, cmdSize %zu, bufSize %zu, lethal "
+            ERR("%s: failed, pos %zu, cmdSize %" PRIu32 ", bufSize %zu, lethal "
                 "error, exiting.", __func__, pos, cmd->cmdSize, m_bufSize);
             abort();
         }
diff --git a/system/gralloc/gralloc_30.cpp b/system/gralloc/gralloc_30.cpp
index b67f4c57..c012908e 100644
--- a/system/gralloc/gralloc_30.cpp
+++ b/system/gralloc/gralloc_30.cpp
@@ -149,7 +149,9 @@ std::unique_ptr<buffer_manager_t> create_buffer_manager(goldfish_gralloc30_modul
 
 class goldfish_gralloc30_module_t {
 public:
-    goldfish_gralloc30_module_t(): m_hostConn(HostConnection::createUnique()) {
+    // TODO(b/142677230): Use unique pointers instead.
+    goldfish_gralloc30_module_t()
+        : m_hostConn(HostConnection::createUnique().release()) {
         CRASH_IF(!m_hostConn, "m_hostConn cannot be nullptr");
         m_bufferManager = create_buffer_manager(this);
         CRASH_IF(!m_bufferManager, "m_bufferManager cannot be nullptr");
diff --git a/system/gralloc/gralloc_old.cpp b/system/gralloc/gralloc_old.cpp
index 7af9dfe9..40f6b6c5 100644
--- a/system/gralloc/gralloc_old.cpp
+++ b/system/gralloc/gralloc_old.cpp
@@ -446,7 +446,7 @@ static HostConnection* sHostCon = NULL;
 
 static HostConnection* createOrGetHostConnection() {
     if (!sHostCon) {
-        sHostCon = HostConnection::createUnique();
+        sHostCon = HostConnection::createUnique().release();
     }
     return sHostCon;
 }
diff --git a/system/hwc2/EmuHWC2.cpp b/system/hwc2/EmuHWC2.cpp
index e77e27df..7cdbd60d 100644
--- a/system/hwc2/EmuHWC2.cpp
+++ b/system/hwc2/EmuHWC2.cpp
@@ -47,13 +47,13 @@ static hwc2_function_pointer_t asFP(T function)
     return reinterpret_cast<hwc2_function_pointer_t>(function);
 }
 
-static HostConnection *sHostCon = nullptr;
+static std::unique_ptr<HostConnection> sHostCon;
 
 static HostConnection* createOrGetHostConnection() {
     if (!sHostCon) {
         sHostCon = HostConnection::createUnique();
     }
-    return sHostCon;
+    return sHostCon.get();
 }
 
 #define DEFINE_AND_VALIDATE_HOST_CONNECTION \
diff --git a/system/vulkan/func_table.cpp b/system/vulkan/func_table.cpp
index 721e7c5c..51913e8e 100644
--- a/system/vulkan/func_table.cpp
+++ b/system/vulkan/func_table.cpp
@@ -240,6 +240,7 @@ static VkResult entry_vkQueueSubmit(
 {
     AEMU_SCOPED_TRACE("vkQueueSubmit");
     auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
     VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
     auto resources = ResourceTracker::get();
     vkQueueSubmit_VkResult_return = resources->on_vkQueueSubmit(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
@@ -250,6 +251,7 @@ static VkResult entry_vkQueueWaitIdle(
 {
     AEMU_SCOPED_TRACE("vkQueueWaitIdle");
     auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
     VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
     auto resources = ResourceTracker::get();
     vkQueueWaitIdle_VkResult_return = resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, queue);
@@ -418,6 +420,7 @@ static VkResult entry_vkQueueBindSparse(
 {
     AEMU_SCOPED_TRACE("vkQueueBindSparse");
     auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
     VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
     vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
     return vkQueueBindSparse_VkResult_return;
@@ -2258,6 +2261,7 @@ static VkResult entry_vkQueuePresentKHR(
 {
     AEMU_SCOPED_TRACE("vkQueuePresentKHR");
     auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
     VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
     vkQueuePresentKHR_VkResult_return = vkEnc->vkQueuePresentKHR(queue, pPresentInfo);
     return vkQueuePresentKHR_VkResult_return;
@@ -3679,6 +3683,8 @@ static void entry_vkCmdDrawIndexedIndirectCountKHR(
 #endif
 #ifdef VK_KHR_8bit_storage
 #endif
+#ifdef VK_KHR_shader_float16_int8
+#endif
 #ifdef VK_ANDROID_native_buffer
 static VkResult entry_vkGetSwapchainGrallocUsageANDROID(
     VkDevice device,
@@ -3749,6 +3755,7 @@ static VkResult entry_vkQueueSignalReleaseImageANDROID(
 {
     AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID");
     auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
     VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
     vkQueueSignalReleaseImageANDROID_VkResult_return = vkEnc->vkQueueSignalReleaseImageANDROID(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
     return vkQueueSignalReleaseImageANDROID_VkResult_return;
@@ -4631,6 +4638,7 @@ static void entry_vkQueueBeginDebugUtilsLabelEXT(
 {
     AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT");
     auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
     vkEnc->vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
 }
 static void entry_vkQueueEndDebugUtilsLabelEXT(
@@ -4638,6 +4646,7 @@ static void entry_vkQueueEndDebugUtilsLabelEXT(
 {
     AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT");
     auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
     vkEnc->vkQueueEndDebugUtilsLabelEXT(queue);
 }
 static void entry_vkQueueInsertDebugUtilsLabelEXT(
@@ -4646,6 +4655,7 @@ static void entry_vkQueueInsertDebugUtilsLabelEXT(
 {
     AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT");
     auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
     vkEnc->vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
 }
 static void entry_vkCmdBeginDebugUtilsLabelEXT(
@@ -4990,6 +5000,7 @@ static void entry_vkGetQueueCheckpointDataNV(
 {
     AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV");
     auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
     vkEnc->vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
 }
 #endif
@@ -5285,6 +5296,48 @@ static VkResult dynCheck_entry_vkFreeMemorySyncGOOGLE(
     return vkFreeMemorySyncGOOGLE_VkResult_return;
 }
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+static void entry_vkQueueHostSyncGOOGLE(
+    VkQueue queue,
+    uint32_t needHostSync,
+    uint32_t sequenceNumber)
+{
+    AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
+    vkEnc->vkQueueHostSyncGOOGLE(queue, needHostSync, sequenceNumber);
+}
+static void entry_vkQueueSubmitAsyncGOOGLE(
+    VkQueue queue,
+    uint32_t submitCount,
+    const VkSubmitInfo* pSubmits,
+    VkFence fence)
+{
+    AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
+    vkEnc->vkQueueSubmitAsyncGOOGLE(queue, submitCount, pSubmits, fence);
+}
+static void entry_vkQueueWaitIdleAsyncGOOGLE(
+    VkQueue queue)
+{
+    AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
+    vkEnc->vkQueueWaitIdleAsyncGOOGLE(queue);
+}
+static void entry_vkQueueBindSparseAsyncGOOGLE(
+    VkQueue queue,
+    uint32_t bindInfoCount,
+    const VkBindSparseInfo* pBindInfo,
+    VkFence fence)
+{
+    AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    ResourceTracker::get()->syncEncodersForQueue(queue, vkEnc);
+    vkEnc->vkQueueBindSparseAsyncGOOGLE(queue, bindInfoCount, pBindInfo, fence);
+}
+#endif
 void* goldfish_vulkan_get_proc_address(const char* name){
 #ifdef VK_VERSION_1_0
     if (!strcmp(name, "vkCreateInstance"))
@@ -6742,6 +6795,24 @@ void* goldfish_vulkan_get_proc_address(const char* name){
         return nullptr;
     }
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+    if (!strcmp(name, "vkQueueHostSyncGOOGLE"))
+    {
+        return nullptr;
+    }
+    if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE"))
+    {
+        return nullptr;
+    }
+    if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE"))
+    {
+        return nullptr;
+    }
+    if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE"))
+    {
+        return nullptr;
+    }
+#endif
     return nullptr;
 }
 void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name){
@@ -8296,6 +8367,28 @@ void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char*
         return (void*)dynCheck_entry_vkFreeMemorySyncGOOGLE;
     }
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+    if (!strcmp(name, "vkQueueHostSyncGOOGLE"))
+    {
+        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_async_queue_submit");
+        return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
+    }
+    if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE"))
+    {
+        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_async_queue_submit");
+        return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
+    }
+    if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE"))
+    {
+        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_async_queue_submit");
+        return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
+    }
+    if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE"))
+    {
+        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_async_queue_submit");
+        return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
+    }
+#endif
     return nullptr;
 }
 void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name){
@@ -9921,6 +10014,28 @@ void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name)
         return hasExt ? (void*)entry_vkFreeMemorySyncGOOGLE : nullptr;
     }
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+    if (!strcmp(name, "vkQueueHostSyncGOOGLE"))
+    {
+        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_async_queue_submit");
+        return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
+    }
+    if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE"))
+    {
+        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_async_queue_submit");
+        return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
+    }
+    if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE"))
+    {
+        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_async_queue_submit");
+        return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
+    }
+    if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE"))
+    {
+        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_async_queue_submit");
+        return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
+    }
+#endif
     return nullptr;
 }
 
diff --git a/system/vulkan/func_table.h b/system/vulkan/func_table.h
index c0d42241..9c2e5beb 100644
--- a/system/vulkan/func_table.h
+++ b/system/vulkan/func_table.h
@@ -134,6 +134,8 @@ namespace goldfish_vk {
 #endif
 #ifdef VK_KHR_8bit_storage
 #endif
+#ifdef VK_KHR_shader_float16_int8
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_debug_report
@@ -290,6 +292,8 @@ namespace goldfish_vk {
 #endif
 #ifdef VK_GOOGLE_free_memory_sync
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#endif
 void* goldfish_vulkan_get_proc_address(const char* name);
 void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name);
 void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name);
diff --git a/system/vulkan/goldfish_vulkan.cpp b/system/vulkan/goldfish_vulkan.cpp
index 44071ec8..821a68a9 100644
--- a/system/vulkan/goldfish_vulkan.cpp
+++ b/system/vulkan/goldfish_vulkan.cpp
@@ -221,6 +221,14 @@ SetBufferCollectionConstraintsFUCHSIA(VkDevice /*device*/,
     return VK_SUCCESS;
 }
 
+VkResult SetBufferCollectionBufferConstraintsFUCHSIA(
+    VkDevice /*device*/,
+    VkBufferCollectionFUCHSIA /*collection*/,
+    const VkBufferConstraintsInfoFUCHSIA* /*pBufferConstraintsInfo*/) {
+    AEMU_SCOPED_TRACE("vkstubhal::SetBufferCollectionBufferConstraintsFUCHSIA");
+    return VK_SUCCESS;
+}
+
 VkResult
 GetBufferCollectionPropertiesFUCHSIA(VkDevice /*device*/,
                                      VkBufferCollectionFUCHSIA /*collection*/,
@@ -279,6 +287,8 @@ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance,
         return reinterpret_cast<PFN_vkVoidFunction>(DestroyBufferCollectionFUCHSIA);
     if (strcmp(name, "vkSetBufferCollectionConstraintsFUCHSIA") == 0)
         return reinterpret_cast<PFN_vkVoidFunction>(SetBufferCollectionConstraintsFUCHSIA);
+    if (strcmp(name, "vkSetBufferCollectionBufferConstraintsFUCHSIA") == 0)
+        return reinterpret_cast<PFN_vkVoidFunction>(SetBufferCollectionBufferConstraintsFUCHSIA);
     if (strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIA") == 0)
         return reinterpret_cast<PFN_vkVoidFunction>(GetBufferCollectionPropertiesFUCHSIA);
 #endif
@@ -354,9 +364,11 @@ int CloseDevice(struct hw_device_t* /*device*/) {
     } \
     goldfish_vk::ResourceTracker::get()->setupFeatures(rcEnc->featureInfo_const()); \
     goldfish_vk::ResourceTracker::ThreadingCallbacks threadingCallbacks = { \
-        [] { auto hostCon = HostConnection::get(); \
-            ExtendedRCEncoderContext *rcEnc = hostCon->rcEncoder(); \
-            return hostCon; }, \
+        [] { \
+          auto hostCon = HostConnection::get(); \
+          hostCon->rcEncoder(); \
+          return hostCon; \
+        }, \
         [](HostConnection* hostCon) { return hostCon->vkEncoder(); }, \
     }; \
     goldfish_vk::ResourceTracker::get()->setThreadingCallbacks(threadingCallbacks); \
@@ -554,6 +566,27 @@ VkResult SetBufferCollectionConstraintsFUCHSIA(
 }
 
 VKAPI_ATTR
+VkResult SetBufferCollectionBufferConstraintsFUCHSIA(
+    VkDevice device,
+    VkBufferCollectionFUCHSIA collection,
+    const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
+    AEMU_SCOPED_TRACE("goldfish_vulkan::SetBufferCollectionBufferConstraintsFUCHSIA");
+
+    VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
+
+    if (!hostSupportsVulkan) {
+        return vkstubhal::SetBufferCollectionBufferConstraintsFUCHSIA(device, collection,
+                                                                      pBufferConstraintsInfo);
+    }
+
+    VkResult res =
+        goldfish_vk::ResourceTracker::get()->on_vkSetBufferCollectionBufferConstraintsFUCHSIA(
+            vkEnc, VK_SUCCESS, device, collection, pBufferConstraintsInfo);
+
+    return res;
+}
+
+VKAPI_ATTR
 VkResult GetBufferCollectionPropertiesFUCHSIA(
     VkDevice device,
     VkBufferCollectionFUCHSIA collection,
@@ -605,6 +638,9 @@ static PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* name) {
     if (!strcmp(name, "vkSetBufferCollectionConstraintsFUCHSIA")) {
         return (PFN_vkVoidFunction)SetBufferCollectionConstraintsFUCHSIA;
     }
+    if (!strcmp(name, "vkSetBufferCollectionBufferConstraintsFUCHSIA")) {
+        return (PFN_vkVoidFunction)SetBufferCollectionBufferConstraintsFUCHSIA;
+    }
     if (!strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIA")) {
         return (PFN_vkVoidFunction)GetBufferCollectionPropertiesFUCHSIA;
     }
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
index c364b32f..2293df01 100644
--- a/system/vulkan_enc/ResourceTracker.cpp
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -275,6 +275,11 @@ public:
         uint32_t sequenceNumber = 0;
     };
 
+    struct VkQueue_Info {
+        VkEncoder** lastUsedEncoderPtr = nullptr;
+        uint32_t sequenceNumber = 0;
+    };
+
     // custom guest-side structs for images/buffers because of AHardwareBuffer :((
     struct VkImage_Info {
         VkDevice device;
@@ -394,13 +399,31 @@ public:
             *(info.lastUsedEncoderPtr) : nullptr;
 
         if (lastUsedEncoder) {
-            lastUsedEncoder->unregisterCleanupCallback(commandBuffer);
             delete info.lastUsedEncoderPtr;
+            info.lastUsedEncoderPtr = nullptr;
         }
 
         info_VkCommandBuffer.erase(commandBuffer);
     }
 
+    void unregister_VkQueue(VkQueue queue) {
+        AutoLock lock(mLock);
+
+        auto it = info_VkQueue.find(queue);
+        if (it == info_VkQueue.end()) return;
+        auto& info = it->second;
+        auto lastUsedEncoder =
+            info.lastUsedEncoderPtr ?
+            *(info.lastUsedEncoderPtr) : nullptr;
+
+        if (lastUsedEncoder) {
+            delete info.lastUsedEncoderPtr;
+            info.lastUsedEncoderPtr = nullptr;
+        }
+
+        info_VkQueue.erase(queue);
+    }
+
     void unregister_VkDeviceMemory(VkDeviceMemory mem) {
         AutoLock lock(mLock);
 
@@ -804,6 +827,9 @@ public:
         if (mFeatureInfo->hasVulkanIgnoredHandles) {
             mStreamFeatureBits |= VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT;
         }
+        if (mFeatureInfo->hasVulkanShaderFloat16Int8) {
+            mStreamFeatureBits |= VULKAN_STREAM_FEATURE_SHADER_FLOAT16_INT8_BIT;
+        }
 
 #if !defined(HOST_BUILD) && defined(VK_USE_PLATFORM_ANDROID_KHR)
         if (mFeatureInfo->hasVirtioGpuNext) {
@@ -836,6 +862,11 @@ public:
         return mFeatureInfo->hasDeferredVulkanCommands;
     }
 
+    bool supportsAsyncQueueSubmit() const {
+        if (!mFeatureInfo) return false;
+        return mFeatureInfo->hasVulkanAsyncQueueSubmit;
+    }
+
     bool supportsCreateResourcesWithRequirements() const {
         if (!mFeatureInfo) return false;
         return mFeatureInfo->hasVulkanCreateResourcesWithRequirements;
@@ -1677,18 +1708,15 @@ public:
         delete sysmem_collection;
     }
 
-    VkResult setBufferCollectionConstraints(fuchsia::sysmem::BufferCollectionSyncPtr* collection,
-                                            const VkImageCreateInfo* pImageInfo,
-                                            size_t min_size_bytes) {
+    inline fuchsia::sysmem::BufferCollectionConstraints
+    defaultBufferCollectionConstraints(size_t min_size_bytes,
+                                       size_t buffer_count) {
         fuchsia::sysmem::BufferCollectionConstraints constraints = {};
-        constraints.usage.vulkan = fuchsia::sysmem::vulkanUsageColorAttachment |
-                                   fuchsia::sysmem::vulkanUsageTransferSrc |
-                                   fuchsia::sysmem::vulkanUsageTransferDst |
-                                   fuchsia::sysmem::vulkanUsageSampled;
-        constraints.min_buffer_count = 1;
+        constraints.min_buffer_count = buffer_count;
         constraints.has_buffer_memory_constraints = true;
         fuchsia::sysmem::BufferMemoryConstraints& buffer_constraints =
             constraints.buffer_memory_constraints;
+
         buffer_constraints.min_size_bytes = min_size_bytes;
         buffer_constraints.max_size_bytes = 0xffffffff;
         buffer_constraints.physically_contiguous_required = false;
@@ -1700,6 +1728,72 @@ public:
         buffer_constraints.heap_permitted[0] =
             fuchsia::sysmem::HeapType::GOLDFISH_DEVICE_LOCAL;
 
+        return constraints;
+    }
+
+    uint32_t getBufferCollectionConstraintsVulkanImageUsage(
+        const VkImageCreateInfo* pImageInfo) {
+        uint32_t usage = 0u;
+        VkImageUsageFlags imageUsage = pImageInfo->usage;
+
+#define SetUsageBit(USAGE)                                    \
+    if (imageUsage & VK_IMAGE_USAGE_##USAGE##_BIT) {          \
+        usage |= fuchsia::sysmem::VULKAN_IMAGE_USAGE_##USAGE; \
+    }
+
+        SetUsageBit(COLOR_ATTACHMENT);
+        SetUsageBit(TRANSFER_SRC);
+        SetUsageBit(TRANSFER_DST);
+        SetUsageBit(SAMPLED);
+
+#undef SetUsageBit
+        return usage;
+    }
+
+    uint32_t getBufferCollectionConstraintsVulkanBufferUsage(
+        const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
+        uint32_t usage = 0u;
+        VkBufferUsageFlags bufferUsage =
+            pBufferConstraintsInfo->pBufferCreateInfo->usage;
+
+#define SetUsageBit(USAGE)                                     \
+    if (bufferUsage & VK_BUFFER_USAGE_##USAGE##_BIT) {         \
+        usage |= fuchsia::sysmem::VULKAN_BUFFER_USAGE_##USAGE; \
+    }
+
+        SetUsageBit(TRANSFER_SRC);
+        SetUsageBit(TRANSFER_DST);
+        SetUsageBit(UNIFORM_TEXEL_BUFFER);
+        SetUsageBit(STORAGE_TEXEL_BUFFER);
+        SetUsageBit(UNIFORM_BUFFER);
+        SetUsageBit(STORAGE_BUFFER);
+        SetUsageBit(INDEX_BUFFER);
+        SetUsageBit(VERTEX_BUFFER);
+        SetUsageBit(INDIRECT_BUFFER);
+
+#undef SetUsageBit
+        return usage;
+    }
+
+    VkResult setBufferCollectionConstraints(
+        fuchsia::sysmem::BufferCollectionSyncPtr* collection,
+        const VkImageCreateInfo* pImageInfo) {
+        if (pImageInfo == nullptr) {
+            ALOGE("setBufferCollectionConstraints: pImageInfo cannot be null.");
+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        }
+
+        // TODO(liyl): Currently the size only works for RGBA8 and BGRA8 images.
+        // We should set the size based on its actual format.
+        fuchsia::sysmem::BufferCollectionConstraints constraints =
+            defaultBufferCollectionConstraints(
+                /* min_size_bytes */ pImageInfo->extent.width *
+                    pImageInfo->extent.height * 4,
+                /* buffer_count */ 1u);
+
+        constraints.usage.vulkan =
+            getBufferCollectionConstraintsVulkanImageUsage(pImageInfo);
+
         // Set image format constraints for VkImage allocation.
         if (pImageInfo) {
             std::vector<VkFormat> formats{pImageInfo->format};
@@ -1765,17 +1859,49 @@ public:
         return VK_SUCCESS;
     }
 
+    VkResult setBufferCollectionBufferConstraints(
+        fuchsia::sysmem::BufferCollectionSyncPtr* collection,
+        const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
+        if (pBufferConstraintsInfo == nullptr) {
+            ALOGE(
+                "setBufferCollectionBufferConstraints: "
+                "pBufferConstraintsInfo cannot be null.");
+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        }
+
+        fuchsia::sysmem::BufferCollectionConstraints constraints =
+            defaultBufferCollectionConstraints(
+                /* min_size_bytes */ pBufferConstraintsInfo->pBufferCreateInfo
+                    ->size,
+                /* buffer_count */ pBufferConstraintsInfo->minCount);
+        constraints.usage.vulkan =
+            getBufferCollectionConstraintsVulkanBufferUsage(
+                pBufferConstraintsInfo);
+
+        (*collection)->SetConstraints(true, constraints);
+        return VK_SUCCESS;
+    }
+
     VkResult on_vkSetBufferCollectionConstraintsFUCHSIA(
         void*, VkResult, VkDevice,
         VkBufferCollectionFUCHSIA collection,
         const VkImageCreateInfo* pImageInfo) {
         auto sysmem_collection =
             reinterpret_cast<fuchsia::sysmem::BufferCollectionSyncPtr*>(collection);
-        size_t minSizeBytes = pImageInfo ? pImageInfo->extent.width *
-                                                   pImageInfo->extent.height * 4
-                                         : 0u;
-        return setBufferCollectionConstraints(sysmem_collection, pImageInfo,
-                                              minSizeBytes);
+        return setBufferCollectionConstraints(sysmem_collection, pImageInfo);
+    }
+
+    VkResult on_vkSetBufferCollectionBufferConstraintsFUCHSIA(
+        void*,
+        VkResult,
+        VkDevice,
+        VkBufferCollectionFUCHSIA collection,
+        const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
+        auto sysmem_collection =
+            reinterpret_cast<fuchsia::sysmem::BufferCollectionSyncPtr*>(
+                collection);
+        return setBufferCollectionBufferConstraints(sysmem_collection,
+                                                    pBufferConstraintsInfo);
     }
 
     VkResult on_vkGetBufferCollectionPropertiesFUCHSIA(
@@ -2199,9 +2325,30 @@ public:
         if (exportVmo) {
             bool hasDedicatedImage = dedicatedAllocInfoPtr &&
                 (dedicatedAllocInfoPtr->image != VK_NULL_HANDLE);
-            VkImageCreateInfo imageCreateInfo = {};
+            bool hasDedicatedBuffer =
+                dedicatedAllocInfoPtr &&
+                (dedicatedAllocInfoPtr->buffer != VK_NULL_HANDLE);
+
+            if (hasDedicatedImage && hasDedicatedBuffer) {
+                ALOGE(
+                    "Invalid VkMemoryDedicatedAllocationInfo: At least one "
+                    "of image and buffer must be VK_NULL_HANDLE.");
+                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+            }
+
+            const VkImageCreateInfo* pImageCreateInfo = nullptr;
+
+            VkBufferConstraintsInfoFUCHSIA bufferConstraintsInfo = {
+                .sType =
+                    VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA,
+                .pNext = nullptr,
+                .pBufferCreateInfo = nullptr,
+                .requiredFormatFeatures = 0,
+                .minCount = 1,
+            };
+            const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo =
+                nullptr;
 
-            // TODO(liyl): Handle dedicated buffer allocation as well.
             if (hasDedicatedImage) {
                 AutoLock lock(mLock);
 
@@ -2209,13 +2356,31 @@ public:
                 if (it == info_VkImage.end()) return VK_ERROR_INITIALIZATION_FAILED;
                 const auto& imageInfo = it->second;
 
-                imageCreateInfo = imageInfo.createInfo;
+                pImageCreateInfo = &imageInfo.createInfo;
+            }
+
+            if (hasDedicatedBuffer) {
+                AutoLock lock(mLock);
+
+                auto it = info_VkBuffer.find(dedicatedAllocInfoPtr->buffer);
+                if (it == info_VkBuffer.end())
+                    return VK_ERROR_INITIALIZATION_FAILED;
+                const auto& bufferInfo = it->second;
+
+                bufferConstraintsInfo.pBufferCreateInfo =
+                    &bufferInfo.createInfo;
+                pBufferConstraintsInfo = &bufferConstraintsInfo;
             }
 
-            if (imageCreateInfo.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
-                                         VK_IMAGE_USAGE_TRANSFER_DST_BIT |
-                                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
-                                         VK_IMAGE_USAGE_SAMPLED_BIT)) {
+            hasDedicatedImage = hasDedicatedImage &&
+                                getBufferCollectionConstraintsVulkanImageUsage(
+                                    pImageCreateInfo);
+            hasDedicatedBuffer =
+                hasDedicatedBuffer &&
+                getBufferCollectionConstraintsVulkanBufferUsage(
+                    pBufferConstraintsInfo);
+
+            if (hasDedicatedImage || hasDedicatedBuffer) {
                 fuchsia::sysmem::BufferCollectionTokenSyncPtr token;
                 zx_status_t status = mSysmemAllocator->AllocateSharedCollection(
                     token.NewRequest());
@@ -2231,12 +2396,24 @@ public:
                     ALOGE("BindSharedCollection failed: %d", status);
                     abort();
                 }
-                VkResult res = setBufferCollectionConstraints(&collection,
-                                                              &imageCreateInfo,
-                                                              finalAllocInfo.allocationSize);
-                if (res != VK_SUCCESS) {
-                    ALOGE("setBufferCollectionConstraints failed: %d", res);
-                    abort();
+
+                if (hasDedicatedImage) {
+                    VkResult res = setBufferCollectionConstraints(
+                        &collection, pImageCreateInfo);
+                    if (res != VK_SUCCESS) {
+                        ALOGE("setBufferCollectionConstraints failed: %d", res);
+                        abort();
+                    }
+                }
+
+                if (hasDedicatedBuffer) {
+                    VkResult res = setBufferCollectionBufferConstraints(
+                        &collection, pBufferConstraintsInfo);
+                    if (res != VK_SUCCESS) {
+                        ALOGE("setBufferCollectionBufferConstraints failed: %d",
+                              res);
+                        abort();
+                    }
                 }
 
                 fuchsia::sysmem::BufferCollectionInfo_2 info;
@@ -2264,38 +2441,52 @@ public:
                     abort();
                 }
 
-                fuchsia::hardware::goldfish::ColorBufferFormatType format;
-                switch (imageCreateInfo.format) {
-                case VK_FORMAT_B8G8R8A8_SINT:
-                case VK_FORMAT_B8G8R8A8_UNORM:
-                case VK_FORMAT_B8G8R8A8_SRGB:
-                case VK_FORMAT_B8G8R8A8_SNORM:
-                case VK_FORMAT_B8G8R8A8_SSCALED:
-                case VK_FORMAT_B8G8R8A8_USCALED:
-                    format = fuchsia::hardware::goldfish::ColorBufferFormatType::BGRA;
-                    break;
-                case VK_FORMAT_R8G8B8A8_SINT:
-                case VK_FORMAT_R8G8B8A8_UNORM:
-                case VK_FORMAT_R8G8B8A8_SRGB:
-                case VK_FORMAT_R8G8B8A8_SNORM:
-                case VK_FORMAT_R8G8B8A8_SSCALED:
-                case VK_FORMAT_R8G8B8A8_USCALED:
-                    format = fuchsia::hardware::goldfish::ColorBufferFormatType::RGBA;
-                    break;
-                default:
-                    ALOGE("Unsupported format: %d", imageCreateInfo.format);
-                    abort();
+                if (pImageCreateInfo) {
+                    fuchsia::hardware::goldfish::ColorBufferFormatType format;
+                    switch (pImageCreateInfo->format) {
+                        case VK_FORMAT_B8G8R8A8_SINT:
+                        case VK_FORMAT_B8G8R8A8_UNORM:
+                        case VK_FORMAT_B8G8R8A8_SRGB:
+                        case VK_FORMAT_B8G8R8A8_SNORM:
+                        case VK_FORMAT_B8G8R8A8_SSCALED:
+                        case VK_FORMAT_B8G8R8A8_USCALED:
+                            format = fuchsia::hardware::goldfish::
+                                ColorBufferFormatType::BGRA;
+                            break;
+                        case VK_FORMAT_R8G8B8A8_SINT:
+                        case VK_FORMAT_R8G8B8A8_UNORM:
+                        case VK_FORMAT_R8G8B8A8_SRGB:
+                        case VK_FORMAT_R8G8B8A8_SNORM:
+                        case VK_FORMAT_R8G8B8A8_SSCALED:
+                        case VK_FORMAT_R8G8B8A8_USCALED:
+                            format = fuchsia::hardware::goldfish::
+                                ColorBufferFormatType::RGBA;
+                            break;
+                        default:
+                            ALOGE("Unsupported format: %d",
+                                  pImageCreateInfo->format);
+                            abort();
+                    }
+
+                    status = mControlDevice->CreateColorBuffer(
+                        std::move(vmo_copy), pImageCreateInfo->extent.width,
+                        pImageCreateInfo->extent.height, format, &status2);
+                    if (status != ZX_OK || status2 != ZX_OK) {
+                        ALOGE("CreateColorBuffer failed: %d:%d", status,
+                              status2);
+                        abort();
+                    }
                 }
 
-                status = mControlDevice->CreateColorBuffer(
-                    std::move(vmo_copy),
-                    imageCreateInfo.extent.width,
-                    imageCreateInfo.extent.height,
-                    format,
-                    &status2);
-                if (status != ZX_OK || status2 != ZX_OK) {
-                    ALOGE("CreateColorBuffer failed: %d:%d", status, status2);
-                    abort();
+                if (pBufferConstraintsInfo) {
+                    status = mControlDevice->CreateBuffer(
+                        std::move(vmo_copy),
+                        pBufferConstraintsInfo->pBufferCreateInfo->size,
+                        &status2);
+                    if (status != ZX_OK || status2 != ZX_OK) {
+                        ALOGE("CreateBuffer failed: %d:%d", status, status2);
+                        abort();
+                    }
                 }
             }
         }
@@ -3938,8 +4129,13 @@ public:
         lock.unlock();
 
         if (pre_signal_semaphores.empty()) {
-            input_result = enc->vkQueueSubmit(queue, submitCount, pSubmits, fence);
-            if (input_result != VK_SUCCESS) return input_result;
+            if (supportsAsyncQueueSubmit()) {
+                enc->vkQueueSubmitAsyncGOOGLE(queue, submitCount, pSubmits, fence);
+                input_result = VK_SUCCESS;
+            } else {
+                input_result = enc->vkQueueSubmit(queue, submitCount, pSubmits, fence);
+                if (input_result != VK_SUCCESS) return input_result;
+            }
         } else {
             // Schedule waits on the OS external objects and
             // signal the wait semaphores
@@ -3974,10 +4170,20 @@ public:
                 .pWaitDstStageMask = nullptr,
                 .signalSemaphoreCount = static_cast<uint32_t>(pre_signal_semaphores.size()),
                 .pSignalSemaphores = pre_signal_semaphores.data()};
-            enc->vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
 
-            input_result = enc->vkQueueSubmit(queue, submitCount, pSubmits, fence);
-            if (input_result != VK_SUCCESS) return input_result;
+            if (supportsAsyncQueueSubmit()) {
+                enc->vkQueueSubmitAsyncGOOGLE(queue, 1, &submit_info, VK_NULL_HANDLE);
+            } else {
+                enc->vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
+            }
+
+            if (supportsAsyncQueueSubmit()) {
+                enc->vkQueueSubmitAsyncGOOGLE(queue, submitCount, pSubmits, fence);
+                input_result = VK_SUCCESS;
+            } else {
+                input_result = enc->vkQueueSubmit(queue, submitCount, pSubmits, fence);
+                if (input_result != VK_SUCCESS) return input_result;
+            }
         }
 
         lock.lock();
@@ -4424,6 +4630,31 @@ public:
             physicalDevice, pImageFormatInfo, pImageFormatProperties);
     }
 
+    void registerEncoderCleanupCallback(const VkEncoder* encoder, void* object, CleanupCallback callback) {
+        AutoLock lock(mLock);
+        auto& callbacks = mEncoderCleanupCallbacks[encoder];
+        callbacks[object] = callback;
+    }
+    
+    void unregisterEncoderCleanupCallback(const VkEncoder* encoder, void* object) {
+        AutoLock lock(mLock);
+        mEncoderCleanupCallbacks[encoder].erase(object);
+    }
+
+    void onEncoderDeleted(const VkEncoder* encoder) {
+        AutoLock lock(mLock);
+        if (mEncoderCleanupCallbacks.find(encoder) == mEncoderCleanupCallbacks.end()) return;
+
+        std::unordered_map<void*, CleanupCallback> callbackCopies = mEncoderCleanupCallbacks[encoder];
+
+        mEncoderCleanupCallbacks.erase(encoder);
+        lock.unlock();
+
+        for (auto it : callbackCopies) {
+            it.second();
+        }
+    }
+
     uint32_t syncEncodersForCommandBuffer(VkCommandBuffer commandBuffer, VkEncoder* currentEncoder) {
         AutoLock lock(mLock);
 
@@ -4449,17 +4680,87 @@ public:
         if (!lastEncoder) return 0;
         if (lastEncoder == currentEncoder) return 0;
 
-        info.sequenceNumber++;
-        lastEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, false, info.sequenceNumber);
+        auto oldSeq = info.sequenceNumber;
+
+        lock.unlock();
+
+        lastEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, false, oldSeq + 1);
         lastEncoder->flush();
-        info.sequenceNumber++;
-        currentEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, true, info.sequenceNumber);
+        currentEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, true, oldSeq + 2);
+
+        unregisterEncoderCleanupCallback(lastEncoder, commandBuffer);
+
+        registerEncoderCleanupCallback(currentEncoder, commandBuffer, [this, currentEncoder, commandBuffer]() {
+            AutoLock lock(mLock);
+            auto it = info_VkCommandBuffer.find(commandBuffer);
+            if (it == info_VkCommandBuffer.end()) return;
 
-        lastEncoder->unregisterCleanupCallback(commandBuffer);
+            auto& info = it->second;
+            if (!info.lastUsedEncoderPtr) return;
+            if (!*(info.lastUsedEncoderPtr)) return;
 
-        currentEncoder->registerCleanupCallback(commandBuffer, [currentEncoder, lastUsedEncoderPtr]() {
-            if (*(lastUsedEncoderPtr) == currentEncoder) {
-                *(lastUsedEncoderPtr) = nullptr;
+            if (currentEncoder == *(info.lastUsedEncoderPtr)) {
+                *(info.lastUsedEncoderPtr) = nullptr;
+            }
+        });
+
+        return 1;
+    }
+
+    uint32_t syncEncodersForQueue(VkQueue queue, VkEncoder* currentEncoder) {
+        if (!supportsAsyncQueueSubmit()) {
+            return 0;
+        }
+
+        AutoLock lock(mLock);
+
+        auto it = info_VkQueue.find(queue);
+        if (it == info_VkQueue.end()) return 0;
+
+        auto& info = it->second;
+
+        if (!info.lastUsedEncoderPtr) {
+            info.lastUsedEncoderPtr = new VkEncoder*;
+            *(info.lastUsedEncoderPtr) = currentEncoder;
+        }
+
+        auto lastUsedEncoderPtr = info.lastUsedEncoderPtr;
+
+        auto lastEncoder = *(lastUsedEncoderPtr);
+
+        // We always make lastUsedEncoderPtr track
+        // the current encoder, even if the last encoder
+        // is null.
+        *(lastUsedEncoderPtr) = currentEncoder;
+
+        if (!lastEncoder) return 0;
+        if (lastEncoder == currentEncoder) return 0;
+
+        auto oldSeq = info.sequenceNumber;
+
+        info.sequenceNumber += 2;
+
+        lock.unlock();
+
+        // at this point the seqno for the old thread is determined
+
+        lastEncoder->vkQueueHostSyncGOOGLE(queue, false, oldSeq + 1);
+        lastEncoder->flush();
+        currentEncoder->vkQueueHostSyncGOOGLE(queue, true, oldSeq + 2);
+
+        unregisterEncoderCleanupCallback(lastEncoder, queue);
+
+        registerEncoderCleanupCallback(currentEncoder, queue, [this, currentEncoder, queue]() {
+            AutoLock lock(mLock);
+            auto it = info_VkQueue.find(queue);
+            if (it == info_VkQueue.end()) return;
+
+            auto& info = it->second;
+            if (!info.lastUsedEncoderPtr) return;
+            if (!*(info.lastUsedEncoderPtr)) return;
+
+            if (currentEncoder == *(info.lastUsedEncoderPtr)) {
+                *(info.lastUsedEncoderPtr) = nullptr;
             }
         });
 
@@ -4610,6 +4911,9 @@ private:
     WorkPool mWorkPool { 4 };
     std::unordered_map<VkQueue, std::vector<WorkPool::WaitGroupHandle>>
         mQueueSensitiveWorkPoolItems;
+
+    std::unordered_map<const VkEncoder*, std::unordered_map<void*, CleanupCallback>> mEncoderCleanupCallbacks;
+
 };
 
 ResourceTracker::ResourceTracker() : mImpl(new ResourceTracker::Impl()) { }
@@ -5085,6 +5389,15 @@ VkResult ResourceTracker::on_vkSetBufferCollectionConstraintsFUCHSIA(
         context, input_result, device, collection, pImageInfo);
 }
 
+VkResult ResourceTracker::on_vkSetBufferCollectionBufferConstraintsFUCHSIA(
+        void* context, VkResult input_result,
+        VkDevice device,
+        VkBufferCollectionFUCHSIA collection,
+        const VkBufferConstraintsInfoFUCHSIA* pBufferDConstraintsInfo) {
+    return mImpl->on_vkSetBufferCollectionBufferConstraintsFUCHSIA(
+        context, input_result, device, collection, pBufferDConstraintsInfo);
+}
+
 VkResult ResourceTracker::on_vkGetBufferCollectionPropertiesFUCHSIA(
         void* context, VkResult input_result,
         VkDevice device,
@@ -5384,10 +5697,27 @@ VkResult ResourceTracker::on_vkGetPhysicalDeviceImageFormatProperties2KHR(
         pImageFormatProperties);
 }
 
+void ResourceTracker::registerEncoderCleanupCallback(const VkEncoder* encoder, void* handle, ResourceTracker::CleanupCallback callback) {
+    mImpl->registerEncoderCleanupCallback(encoder, handle, callback);
+}
+
+void ResourceTracker::unregisterEncoderCleanupCallback(const VkEncoder* encoder, void* handle) {
+    mImpl->unregisterEncoderCleanupCallback(encoder, handle);
+}
+
+void ResourceTracker::onEncoderDeleted(const VkEncoder* encoder) {
+    mImpl->onEncoderDeleted(encoder);
+}
+
 uint32_t ResourceTracker::syncEncodersForCommandBuffer(VkCommandBuffer commandBuffer, VkEncoder* current) {
     return mImpl->syncEncodersForCommandBuffer(commandBuffer, current);
 }
 
+uint32_t ResourceTracker::syncEncodersForQueue(VkQueue queue, VkEncoder* current) {
+    return mImpl->syncEncodersForQueue(queue, current);
+}
+
+
 VkResult ResourceTracker::on_vkBeginCommandBuffer(
     void* context, VkResult input_result,
     VkCommandBuffer commandBuffer,
diff --git a/system/vulkan_enc/ResourceTracker.h b/system/vulkan_enc/ResourceTracker.h
index 63cfc41e..200150fa 100644
--- a/system/vulkan_enc/ResourceTracker.h
+++ b/system/vulkan_enc/ResourceTracker.h
@@ -20,6 +20,7 @@
 
 #include "VulkanHandleMapping.h"
 #include "VulkanHandles.h"
+#include <functional>
 #include <memory>
 
 #include "goldfish_vk_transform_guest.h"
@@ -44,6 +45,7 @@ public:
 
     using HostConnectionGetFunc = HostConnection* (*)();
     using VkEncoderGetFunc = VkEncoder* (*)(HostConnection*);
+    using CleanupCallback = std::function<void()>;
 
     struct ThreadingCallbacks {
         HostConnectionGetFunc hostConnectionGetFunc = 0;
@@ -274,6 +276,12 @@ public:
         VkDevice device,
         VkBufferCollectionFUCHSIA collection,
         const VkImageCreateInfo* pImageInfo);
+    VkResult on_vkSetBufferCollectionBufferConstraintsFUCHSIA(
+        void* context,
+        VkResult input_result,
+        VkDevice device,
+        VkBufferCollectionFUCHSIA collection,
+        const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo);
     VkResult on_vkGetBufferCollectionPropertiesFUCHSIA(
         void* context, VkResult input_result,
         VkDevice device,
@@ -474,7 +482,12 @@ public:
         const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
         VkImageFormatProperties2* pImageFormatProperties);
 
+    void registerEncoderCleanupCallback(const VkEncoder* encoder, void* handle, CleanupCallback callback);
+    void unregisterEncoderCleanupCallback(const VkEncoder* encoder, void* handle);
+    void onEncoderDeleted(const VkEncoder* encoder);
+
     uint32_t syncEncodersForCommandBuffer(VkCommandBuffer commandBuffer, VkEncoder* current);
+    uint32_t syncEncodersForQueue(VkQueue queue, VkEncoder* current);
 
     VkResult on_vkBeginCommandBuffer(
         void* context, VkResult input_result,
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
index 06ef7f0e..0eeba153 100644
--- a/system/vulkan_enc/VkEncoder.cpp
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -69,12 +69,7 @@ public:
         }
     }
 
-    ~Impl() {
-        for (auto it : mCleanupCallbacks) {
-            fprintf(stderr, "%s: run cleanup callback for %p\n", __func__, it.first);
-            it.second();
-        }
-    }
+    ~Impl() { }
 
     VulkanCountingStream* countingStream() { return &m_countingStream; }
     VulkanStreamGuest* stream() { return &m_stream; }
@@ -88,24 +83,34 @@ public:
     }
 
     void flush() {
-        AutoLock encoderLock(lock);
+        lock();
         m_stream.flush();
+        unlock();
     }
 
-    // Assume the lock for the current encoder is held.
-    void registerCleanupCallback(void* handle, VkEncoder::CleanupCallback cb) {
-        if (mCleanupCallbacks.end() == mCleanupCallbacks.find(handle)) {
-            mCleanupCallbacks[handle] = cb;
-        } else {
-            return;
+    // can be recursive
+    void lock() {
+        if (this == sAcquiredEncoderThreadLocal) {
+            ++sAcquiredEncoderThreadLockLevels;
+            return; // recursive
         }
+        while (mLock.test_and_set(std::memory_order_acquire));
+        sAcquiredEncoderThreadLocal = this;
+        sAcquiredEncoderThreadLockLevels = 1;
     }
 
-    void unregisterCleanupCallback(void* handle) {
-        mCleanupCallbacks.erase(handle);
-    }
+    void unlock() {
+        if (this != sAcquiredEncoderThreadLocal) {
+            // error, trying to unlock without having locked first
+            return;
+        }
 
-    Lock lock;
+        --sAcquiredEncoderThreadLockLevels;
+        if (0 == sAcquiredEncoderThreadLockLevels) {
+            mLock.clear(std::memory_order_release);
+            sAcquiredEncoderThreadLocal = nullptr;
+        }
+    }
 
 private:
     VulkanCountingStream m_countingStream;
@@ -114,8 +119,29 @@ private:
 
     Validation m_validation;
     bool m_logEncodes;
+    std::atomic_flag mLock = ATOMIC_FLAG_INIT;
+    static thread_local Impl* sAcquiredEncoderThreadLocal;
+    static thread_local uint32_t sAcquiredEncoderThreadLockLevels;
+};
+
+VkEncoder::~VkEncoder() {
+    auto rt = ResourceTracker::get();
+    if (!rt) return;
+    rt->onEncoderDeleted(this);
+}
+
+// static
+thread_local VkEncoder::Impl* VkEncoder::Impl::sAcquiredEncoderThreadLocal = nullptr;
+thread_local uint32_t VkEncoder::Impl::sAcquiredEncoderThreadLockLevels = 0;
 
-    std::unordered_map<void*, VkEncoder::CleanupCallback> mCleanupCallbacks;
+struct EncoderAutoLock {
+    EncoderAutoLock(VkEncoder* enc) : mEnc(enc) {
+        mEnc->lock();
+    }
+    ~EncoderAutoLock() {
+        mEnc->unlock();
+    }
+    VkEncoder* mEnc;
 };
 
 VkEncoder::VkEncoder(IOStream *stream) :
@@ -125,12 +151,12 @@ void VkEncoder::flush() {
     mImpl->flush();
 }
 
-void VkEncoder::registerCleanupCallback(void* handle, VkEncoder::CleanupCallback cb) {
-    mImpl->registerCleanupCallback(handle, cb);
+void VkEncoder::lock() {
+    mImpl->lock();
 }
 
-void VkEncoder::unregisterCleanupCallback(void* handle) {
-    mImpl->unregisterCleanupCallback(handle);
+void VkEncoder::unlock() {
+    mImpl->unlock();
 }
 
 #define VALIDATE_RET(retType, success, validate) \
@@ -147,7 +173,7 @@ VkResult VkEncoder::vkCreateInstance(
     const VkAllocationCallbacks* pAllocator,
     VkInstance* pInstance)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateInstance encode");
     mImpl->log("start vkCreateInstance");
     auto stream = mImpl->stream();
@@ -219,12 +245,10 @@ VkResult VkEncoder::vkCreateInstance(
     AEMU_SCOPED_TRACE("vkCreateInstance returnUnmarshal");
     VkResult vkCreateInstance_VkResult_return = (VkResult)0;
     stream->read(&vkCreateInstance_VkResult_return, sizeof(VkResult));
+    mImpl->resources()->on_vkCreateInstance(this, vkCreateInstance_VkResult_return, pCreateInfo, pAllocator, pInstance);
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
-    encoderLock.unlock();
-    mImpl->resources()->on_vkCreateInstance(this, vkCreateInstance_VkResult_return, pCreateInfo, pAllocator, pInstance);
-    encoderLock.lock();
     mImpl->log("finish vkCreateInstance");;
     return vkCreateInstance_VkResult_return;
 }
@@ -233,7 +257,7 @@ void VkEncoder::vkDestroyInstance(
     VkInstance instance,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyInstance encode");
     mImpl->log("start vkDestroyInstance");
     auto stream = mImpl->stream();
@@ -286,6 +310,9 @@ void VkEncoder::vkDestroyInstance(
     AEMU_SCOPED_TRACE("vkDestroyInstance readParams");
     AEMU_SCOPED_TRACE("vkDestroyInstance returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkInstance((VkInstance*)&instance);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyInstance");;
 }
 
@@ -294,7 +321,7 @@ VkResult VkEncoder::vkEnumeratePhysicalDevices(
     uint32_t* pPhysicalDeviceCount,
     VkPhysicalDevice* pPhysicalDevices)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices encode");
     mImpl->log("start vkEnumeratePhysicalDevices");
     auto stream = mImpl->stream();
@@ -394,9 +421,9 @@ VkResult VkEncoder::vkEnumeratePhysicalDevices(
     AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices returnUnmarshal");
     VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
     stream->read(&vkEnumeratePhysicalDevices_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkEnumeratePhysicalDevices");;
     return vkEnumeratePhysicalDevices_VkResult_return;
 }
@@ -405,7 +432,7 @@ void VkEncoder::vkGetPhysicalDeviceFeatures(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceFeatures* pFeatures)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures encode");
     mImpl->log("start vkGetPhysicalDeviceFeatures");
     auto stream = mImpl->stream();
@@ -438,6 +465,9 @@ void VkEncoder::vkGetPhysicalDeviceFeatures(
         transform_fromhost_VkPhysicalDeviceFeatures(mImpl->resources(), (VkPhysicalDeviceFeatures*)(pFeatures));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceFeatures");;
 }
 
@@ -446,7 +476,7 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties(
     VkFormat format,
     VkFormatProperties* pFormatProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties encode");
     mImpl->log("start vkGetPhysicalDeviceFormatProperties");
     auto stream = mImpl->stream();
@@ -483,6 +513,9 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties(
         transform_fromhost_VkFormatProperties(mImpl->resources(), (VkFormatProperties*)(pFormatProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceFormatProperties");;
 }
 
@@ -495,7 +528,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties(
     VkImageCreateFlags flags,
     VkImageFormatProperties* pImageFormatProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties encode");
     mImpl->log("start vkGetPhysicalDeviceImageFormatProperties");
     auto stream = mImpl->stream();
@@ -550,9 +583,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties returnUnmarshal");
     VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceImageFormatProperties_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceImageFormatProperties");;
     return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
 }
@@ -561,7 +594,7 @@ void VkEncoder::vkGetPhysicalDeviceProperties(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceProperties* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties encode");
     mImpl->log("start vkGetPhysicalDeviceProperties");
     auto stream = mImpl->stream();
@@ -594,9 +627,10 @@ void VkEncoder::vkGetPhysicalDeviceProperties(
         transform_fromhost_VkPhysicalDeviceProperties(mImpl->resources(), (VkPhysicalDeviceProperties*)(pProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties returnUnmarshal");
-    encoderLock.unlock();
     mImpl->resources()->on_vkGetPhysicalDeviceProperties(this, physicalDevice, pProperties);
-    encoderLock.lock();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceProperties");;
 }
 
@@ -605,7 +639,7 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties(
     uint32_t* pQueueFamilyPropertyCount,
     VkQueueFamilyProperties* pQueueFamilyProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties encode");
     mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties");
     auto stream = mImpl->stream();
@@ -697,6 +731,9 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties(
         }
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceQueueFamilyProperties");;
 }
 
@@ -704,7 +741,7 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceMemoryProperties* pMemoryProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties encode");
     mImpl->log("start vkGetPhysicalDeviceMemoryProperties");
     auto stream = mImpl->stream();
@@ -737,9 +774,10 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties(
         transform_fromhost_VkPhysicalDeviceMemoryProperties(mImpl->resources(), (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties returnUnmarshal");
-    encoderLock.unlock();
     mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties(this, physicalDevice, pMemoryProperties);
-    encoderLock.lock();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceMemoryProperties");;
 }
 
@@ -747,7 +785,7 @@ PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr(
     VkInstance instance,
     const char* pName)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetInstanceProcAddr encode");
     mImpl->log("start vkGetInstanceProcAddr");
     auto stream = mImpl->stream();
@@ -783,9 +821,9 @@ PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr(
     AEMU_SCOPED_TRACE("vkGetInstanceProcAddr returnUnmarshal");
     PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
     stream->read(&vkGetInstanceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetInstanceProcAddr");;
     return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
 }
@@ -794,7 +832,7 @@ PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr(
     VkDevice device,
     const char* pName)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDeviceProcAddr encode");
     mImpl->log("start vkGetDeviceProcAddr");
     auto stream = mImpl->stream();
@@ -830,9 +868,9 @@ PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr(
     AEMU_SCOPED_TRACE("vkGetDeviceProcAddr returnUnmarshal");
     PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
     stream->read(&vkGetDeviceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetDeviceProcAddr");;
     return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
 }
@@ -843,7 +881,7 @@ VkResult VkEncoder::vkCreateDevice(
     const VkAllocationCallbacks* pAllocator,
     VkDevice* pDevice)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateDevice encode");
     mImpl->log("start vkCreateDevice");
     auto stream = mImpl->stream();
@@ -923,12 +961,10 @@ VkResult VkEncoder::vkCreateDevice(
     AEMU_SCOPED_TRACE("vkCreateDevice returnUnmarshal");
     VkResult vkCreateDevice_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDevice_VkResult_return, sizeof(VkResult));
+    mImpl->resources()->on_vkCreateDevice(this, vkCreateDevice_VkResult_return, physicalDevice, pCreateInfo, pAllocator, pDevice);
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
-    encoderLock.unlock();
-    mImpl->resources()->on_vkCreateDevice(this, vkCreateDevice_VkResult_return, physicalDevice, pCreateInfo, pAllocator, pDevice);
-    encoderLock.lock();
     mImpl->log("finish vkCreateDevice");;
     return vkCreateDevice_VkResult_return;
 }
@@ -937,12 +973,10 @@ void VkEncoder::vkDestroyDevice(
     VkDevice device,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyDevice encode");
     mImpl->log("start vkDestroyDevice");
-    encoderLock.unlock();
     mImpl->resources()->on_vkDestroyDevice_pre(this, device, pAllocator);
-    encoderLock.lock();
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
     auto resources = mImpl->resources();
@@ -994,6 +1028,9 @@ void VkEncoder::vkDestroyDevice(
     AEMU_SCOPED_TRACE("vkDestroyDevice returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDevice((VkDevice*)&device);
     stream->flush();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyDevice");;
 }
 
@@ -1002,7 +1039,7 @@ VkResult VkEncoder::vkEnumerateInstanceExtensionProperties(
     uint32_t* pPropertyCount,
     VkExtensionProperties* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties encode");
     mImpl->log("start vkEnumerateInstanceExtensionProperties");
     auto stream = mImpl->stream();
@@ -1122,9 +1159,9 @@ VkResult VkEncoder::vkEnumerateInstanceExtensionProperties(
     AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties returnUnmarshal");
     VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
     stream->read(&vkEnumerateInstanceExtensionProperties_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkEnumerateInstanceExtensionProperties");;
     return vkEnumerateInstanceExtensionProperties_VkResult_return;
 }
@@ -1135,7 +1172,7 @@ VkResult VkEncoder::vkEnumerateDeviceExtensionProperties(
     uint32_t* pPropertyCount,
     VkExtensionProperties* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties encode");
     mImpl->log("start vkEnumerateDeviceExtensionProperties");
     auto stream = mImpl->stream();
@@ -1263,9 +1300,9 @@ VkResult VkEncoder::vkEnumerateDeviceExtensionProperties(
     AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties returnUnmarshal");
     VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
     stream->read(&vkEnumerateDeviceExtensionProperties_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkEnumerateDeviceExtensionProperties");;
     return vkEnumerateDeviceExtensionProperties_VkResult_return;
 }
@@ -1274,7 +1311,7 @@ VkResult VkEncoder::vkEnumerateInstanceLayerProperties(
     uint32_t* pPropertyCount,
     VkLayerProperties* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties encode");
     mImpl->log("start vkEnumerateInstanceLayerProperties");
     auto stream = mImpl->stream();
@@ -1360,9 +1397,9 @@ VkResult VkEncoder::vkEnumerateInstanceLayerProperties(
     AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties returnUnmarshal");
     VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
     stream->read(&vkEnumerateInstanceLayerProperties_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkEnumerateInstanceLayerProperties");;
     return vkEnumerateInstanceLayerProperties_VkResult_return;
 }
@@ -1372,7 +1409,7 @@ VkResult VkEncoder::vkEnumerateDeviceLayerProperties(
     uint32_t* pPropertyCount,
     VkLayerProperties* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties encode");
     mImpl->log("start vkEnumerateDeviceLayerProperties");
     auto stream = mImpl->stream();
@@ -1466,9 +1503,9 @@ VkResult VkEncoder::vkEnumerateDeviceLayerProperties(
     AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties returnUnmarshal");
     VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
     stream->read(&vkEnumerateDeviceLayerProperties_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkEnumerateDeviceLayerProperties");;
     return vkEnumerateDeviceLayerProperties_VkResult_return;
 }
@@ -1479,7 +1516,7 @@ void VkEncoder::vkGetDeviceQueue(
     uint32_t queueIndex,
     VkQueue* pQueue)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDeviceQueue encode");
     mImpl->log("start vkGetDeviceQueue");
     auto stream = mImpl->stream();
@@ -1526,6 +1563,9 @@ void VkEncoder::vkGetDeviceQueue(
     stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_89, (VkQueue*)pQueue, 1);
     stream->unsetHandleMapping();
     AEMU_SCOPED_TRACE("vkGetDeviceQueue returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetDeviceQueue");;
 }
 
@@ -1535,7 +1575,7 @@ VkResult VkEncoder::vkQueueSubmit(
     const VkSubmitInfo* pSubmits,
     VkFence fence)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkQueueSubmit encode");
     mImpl->log("start vkQueueSubmit");
     auto stream = mImpl->stream();
@@ -1600,9 +1640,9 @@ VkResult VkEncoder::vkQueueSubmit(
     AEMU_SCOPED_TRACE("vkQueueSubmit returnUnmarshal");
     VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
     stream->read(&vkQueueSubmit_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkQueueSubmit");;
     return vkQueueSubmit_VkResult_return;
 }
@@ -1610,7 +1650,7 @@ VkResult VkEncoder::vkQueueSubmit(
 VkResult VkEncoder::vkQueueWaitIdle(
     VkQueue queue)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkQueueWaitIdle encode");
     mImpl->log("start vkQueueWaitIdle");
     auto stream = mImpl->stream();
@@ -1638,9 +1678,9 @@ VkResult VkEncoder::vkQueueWaitIdle(
     AEMU_SCOPED_TRACE("vkQueueWaitIdle returnUnmarshal");
     VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
     stream->read(&vkQueueWaitIdle_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkQueueWaitIdle");;
     return vkQueueWaitIdle_VkResult_return;
 }
@@ -1648,7 +1688,7 @@ VkResult VkEncoder::vkQueueWaitIdle(
 VkResult VkEncoder::vkDeviceWaitIdle(
     VkDevice device)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDeviceWaitIdle encode");
     mImpl->log("start vkDeviceWaitIdle");
     auto stream = mImpl->stream();
@@ -1676,9 +1716,9 @@ VkResult VkEncoder::vkDeviceWaitIdle(
     AEMU_SCOPED_TRACE("vkDeviceWaitIdle returnUnmarshal");
     VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
     stream->read(&vkDeviceWaitIdle_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkDeviceWaitIdle");;
     return vkDeviceWaitIdle_VkResult_return;
 }
@@ -1689,7 +1729,7 @@ VkResult VkEncoder::vkAllocateMemory(
     const VkAllocationCallbacks* pAllocator,
     VkDeviceMemory* pMemory)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkAllocateMemory encode");
     mImpl->log("start vkAllocateMemory");
     auto stream = mImpl->stream();
@@ -1769,9 +1809,9 @@ VkResult VkEncoder::vkAllocateMemory(
     AEMU_SCOPED_TRACE("vkAllocateMemory returnUnmarshal");
     VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
     stream->read(&vkAllocateMemory_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkAllocateMemory");;
     return vkAllocateMemory_VkResult_return;
 }
@@ -1781,7 +1821,7 @@ void VkEncoder::vkFreeMemory(
     VkDeviceMemory memory,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkFreeMemory encode");
     mImpl->log("start vkFreeMemory");
     auto stream = mImpl->stream();
@@ -1839,6 +1879,9 @@ void VkEncoder::vkFreeMemory(
     AEMU_SCOPED_TRACE("vkFreeMemory readParams");
     AEMU_SCOPED_TRACE("vkFreeMemory returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkFreeMemory");;
 }
 
@@ -1870,7 +1913,7 @@ VkResult VkEncoder::vkFlushMappedMemoryRanges(
     uint32_t memoryRangeCount,
     const VkMappedMemoryRange* pMemoryRanges)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges encode");
     mImpl->log("start vkFlushMappedMemoryRanges");
     VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkFlushMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
@@ -1966,9 +2009,9 @@ VkResult VkEncoder::vkFlushMappedMemoryRanges(
     AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges returnUnmarshal");
     VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
     stream->read(&vkFlushMappedMemoryRanges_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkFlushMappedMemoryRanges");;
     return vkFlushMappedMemoryRanges_VkResult_return;
 }
@@ -1978,7 +2021,7 @@ VkResult VkEncoder::vkInvalidateMappedMemoryRanges(
     uint32_t memoryRangeCount,
     const VkMappedMemoryRange* pMemoryRanges)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges encode");
     mImpl->log("start vkInvalidateMappedMemoryRanges");
     VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkInvalidateMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
@@ -2036,9 +2079,6 @@ VkResult VkEncoder::vkInvalidateMappedMemoryRanges(
     AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges returnUnmarshal");
     VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
     stream->read(&vkInvalidateMappedMemoryRanges_VkResult_return, sizeof(VkResult));
-    countingStream->clearPool();
-    stream->clearPool();
-    pool->freeAll();
     if (!resources->usingDirectMapping())
     {
         for (uint32_t i = 0; i < memoryRangeCount; ++i)
@@ -2058,6 +2098,9 @@ VkResult VkEncoder::vkInvalidateMappedMemoryRanges(
             stream->read(targetRange, actualSize);
         }
     }
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkInvalidateMappedMemoryRanges");;
     return vkInvalidateMappedMemoryRanges_VkResult_return;
 }
@@ -2067,7 +2110,7 @@ void VkEncoder::vkGetDeviceMemoryCommitment(
     VkDeviceMemory memory,
     VkDeviceSize* pCommittedMemoryInBytes)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment encode");
     mImpl->log("start vkGetDeviceMemoryCommitment");
     auto stream = mImpl->stream();
@@ -2105,6 +2148,9 @@ void VkEncoder::vkGetDeviceMemoryCommitment(
     AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment readParams");
     stream->read((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
     AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetDeviceMemoryCommitment");;
 }
 
@@ -2114,7 +2160,7 @@ VkResult VkEncoder::vkBindBufferMemory(
     VkDeviceMemory memory,
     VkDeviceSize memoryOffset)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkBindBufferMemory encode");
     mImpl->log("start vkBindBufferMemory");
     auto stream = mImpl->stream();
@@ -2163,9 +2209,9 @@ VkResult VkEncoder::vkBindBufferMemory(
     AEMU_SCOPED_TRACE("vkBindBufferMemory returnUnmarshal");
     VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
     stream->read(&vkBindBufferMemory_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkBindBufferMemory");;
     return vkBindBufferMemory_VkResult_return;
 }
@@ -2176,7 +2222,7 @@ VkResult VkEncoder::vkBindImageMemory(
     VkDeviceMemory memory,
     VkDeviceSize memoryOffset)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkBindImageMemory encode");
     mImpl->log("start vkBindImageMemory");
     auto stream = mImpl->stream();
@@ -2225,9 +2271,9 @@ VkResult VkEncoder::vkBindImageMemory(
     AEMU_SCOPED_TRACE("vkBindImageMemory returnUnmarshal");
     VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
     stream->read(&vkBindImageMemory_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkBindImageMemory");;
     return vkBindImageMemory_VkResult_return;
 }
@@ -2237,7 +2283,7 @@ void VkEncoder::vkGetBufferMemoryRequirements(
     VkBuffer buffer,
     VkMemoryRequirements* pMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements encode");
     mImpl->log("start vkGetBufferMemoryRequirements");
     auto stream = mImpl->stream();
@@ -2278,6 +2324,9 @@ void VkEncoder::vkGetBufferMemoryRequirements(
         transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements));
     }
     AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetBufferMemoryRequirements");;
 }
 
@@ -2286,7 +2335,7 @@ void VkEncoder::vkGetImageMemoryRequirements(
     VkImage image,
     VkMemoryRequirements* pMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements encode");
     mImpl->log("start vkGetImageMemoryRequirements");
     auto stream = mImpl->stream();
@@ -2327,6 +2376,9 @@ void VkEncoder::vkGetImageMemoryRequirements(
         transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements));
     }
     AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetImageMemoryRequirements");;
 }
 
@@ -2336,7 +2388,7 @@ void VkEncoder::vkGetImageSparseMemoryRequirements(
     uint32_t* pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements encode");
     mImpl->log("start vkGetImageSparseMemoryRequirements");
     auto stream = mImpl->stream();
@@ -2436,6 +2488,9 @@ void VkEncoder::vkGetImageSparseMemoryRequirements(
         }
     }
     AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetImageSparseMemoryRequirements");;
 }
 
@@ -2449,7 +2504,7 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties(
     uint32_t* pPropertyCount,
     VkSparseImageFormatProperties* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties encode");
     mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties");
     auto stream = mImpl->stream();
@@ -2561,6 +2616,9 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties(
         }
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceSparseImageFormatProperties");;
 }
 
@@ -2570,7 +2628,7 @@ VkResult VkEncoder::vkQueueBindSparse(
     const VkBindSparseInfo* pBindInfo,
     VkFence fence)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkQueueBindSparse encode");
     mImpl->log("start vkQueueBindSparse");
     auto stream = mImpl->stream();
@@ -2635,9 +2693,9 @@ VkResult VkEncoder::vkQueueBindSparse(
     AEMU_SCOPED_TRACE("vkQueueBindSparse returnUnmarshal");
     VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
     stream->read(&vkQueueBindSparse_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkQueueBindSparse");;
     return vkQueueBindSparse_VkResult_return;
 }
@@ -2648,7 +2706,7 @@ VkResult VkEncoder::vkCreateFence(
     const VkAllocationCallbacks* pAllocator,
     VkFence* pFence)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateFence encode");
     mImpl->log("start vkCreateFence");
     auto stream = mImpl->stream();
@@ -2728,9 +2786,9 @@ VkResult VkEncoder::vkCreateFence(
     AEMU_SCOPED_TRACE("vkCreateFence returnUnmarshal");
     VkResult vkCreateFence_VkResult_return = (VkResult)0;
     stream->read(&vkCreateFence_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateFence");;
     return vkCreateFence_VkResult_return;
 }
@@ -2740,7 +2798,7 @@ void VkEncoder::vkDestroyFence(
     VkFence fence,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyFence encode");
     mImpl->log("start vkDestroyFence");
     auto stream = mImpl->stream();
@@ -2801,6 +2859,9 @@ void VkEncoder::vkDestroyFence(
     AEMU_SCOPED_TRACE("vkDestroyFence readParams");
     AEMU_SCOPED_TRACE("vkDestroyFence returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkFence((VkFence*)&fence);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyFence");;
 }
 
@@ -2809,7 +2870,7 @@ VkResult VkEncoder::vkResetFences(
     uint32_t fenceCount,
     const VkFence* pFences)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkResetFences encode");
     mImpl->log("start vkResetFences");
     auto stream = mImpl->stream();
@@ -2861,9 +2922,9 @@ VkResult VkEncoder::vkResetFences(
     AEMU_SCOPED_TRACE("vkResetFences returnUnmarshal");
     VkResult vkResetFences_VkResult_return = (VkResult)0;
     stream->read(&vkResetFences_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkResetFences");;
     return vkResetFences_VkResult_return;
 }
@@ -2872,7 +2933,7 @@ VkResult VkEncoder::vkGetFenceStatus(
     VkDevice device,
     VkFence fence)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetFenceStatus encode");
     mImpl->log("start vkGetFenceStatus");
     auto stream = mImpl->stream();
@@ -2908,9 +2969,9 @@ VkResult VkEncoder::vkGetFenceStatus(
     AEMU_SCOPED_TRACE("vkGetFenceStatus returnUnmarshal");
     VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
     stream->read(&vkGetFenceStatus_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetFenceStatus");;
     return vkGetFenceStatus_VkResult_return;
 }
@@ -2922,7 +2983,7 @@ VkResult VkEncoder::vkWaitForFences(
     VkBool32 waitAll,
     uint64_t timeout)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkWaitForFences encode");
     mImpl->log("start vkWaitForFences");
     auto stream = mImpl->stream();
@@ -2982,9 +3043,9 @@ VkResult VkEncoder::vkWaitForFences(
     AEMU_SCOPED_TRACE("vkWaitForFences returnUnmarshal");
     VkResult vkWaitForFences_VkResult_return = (VkResult)0;
     stream->read(&vkWaitForFences_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkWaitForFences");;
     return vkWaitForFences_VkResult_return;
 }
@@ -2995,7 +3056,7 @@ VkResult VkEncoder::vkCreateSemaphore(
     const VkAllocationCallbacks* pAllocator,
     VkSemaphore* pSemaphore)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateSemaphore encode");
     mImpl->log("start vkCreateSemaphore");
     auto stream = mImpl->stream();
@@ -3075,9 +3136,9 @@ VkResult VkEncoder::vkCreateSemaphore(
     AEMU_SCOPED_TRACE("vkCreateSemaphore returnUnmarshal");
     VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSemaphore_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateSemaphore");;
     return vkCreateSemaphore_VkResult_return;
 }
@@ -3087,7 +3148,7 @@ void VkEncoder::vkDestroySemaphore(
     VkSemaphore semaphore,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroySemaphore encode");
     mImpl->log("start vkDestroySemaphore");
     auto stream = mImpl->stream();
@@ -3148,6 +3209,9 @@ void VkEncoder::vkDestroySemaphore(
     AEMU_SCOPED_TRACE("vkDestroySemaphore readParams");
     AEMU_SCOPED_TRACE("vkDestroySemaphore returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSemaphore((VkSemaphore*)&semaphore);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroySemaphore");;
 }
 
@@ -3157,7 +3221,7 @@ VkResult VkEncoder::vkCreateEvent(
     const VkAllocationCallbacks* pAllocator,
     VkEvent* pEvent)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateEvent encode");
     mImpl->log("start vkCreateEvent");
     auto stream = mImpl->stream();
@@ -3237,9 +3301,9 @@ VkResult VkEncoder::vkCreateEvent(
     AEMU_SCOPED_TRACE("vkCreateEvent returnUnmarshal");
     VkResult vkCreateEvent_VkResult_return = (VkResult)0;
     stream->read(&vkCreateEvent_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateEvent");;
     return vkCreateEvent_VkResult_return;
 }
@@ -3249,7 +3313,7 @@ void VkEncoder::vkDestroyEvent(
     VkEvent event,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyEvent encode");
     mImpl->log("start vkDestroyEvent");
     auto stream = mImpl->stream();
@@ -3310,6 +3374,9 @@ void VkEncoder::vkDestroyEvent(
     AEMU_SCOPED_TRACE("vkDestroyEvent readParams");
     AEMU_SCOPED_TRACE("vkDestroyEvent returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkEvent((VkEvent*)&event);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyEvent");;
 }
 
@@ -3317,7 +3384,7 @@ VkResult VkEncoder::vkGetEventStatus(
     VkDevice device,
     VkEvent event)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetEventStatus encode");
     mImpl->log("start vkGetEventStatus");
     auto stream = mImpl->stream();
@@ -3353,9 +3420,9 @@ VkResult VkEncoder::vkGetEventStatus(
     AEMU_SCOPED_TRACE("vkGetEventStatus returnUnmarshal");
     VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
     stream->read(&vkGetEventStatus_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetEventStatus");;
     return vkGetEventStatus_VkResult_return;
 }
@@ -3364,7 +3431,7 @@ VkResult VkEncoder::vkSetEvent(
     VkDevice device,
     VkEvent event)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkSetEvent encode");
     mImpl->log("start vkSetEvent");
     auto stream = mImpl->stream();
@@ -3400,9 +3467,9 @@ VkResult VkEncoder::vkSetEvent(
     AEMU_SCOPED_TRACE("vkSetEvent returnUnmarshal");
     VkResult vkSetEvent_VkResult_return = (VkResult)0;
     stream->read(&vkSetEvent_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkSetEvent");;
     return vkSetEvent_VkResult_return;
 }
@@ -3411,7 +3478,7 @@ VkResult VkEncoder::vkResetEvent(
     VkDevice device,
     VkEvent event)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkResetEvent encode");
     mImpl->log("start vkResetEvent");
     auto stream = mImpl->stream();
@@ -3447,9 +3514,9 @@ VkResult VkEncoder::vkResetEvent(
     AEMU_SCOPED_TRACE("vkResetEvent returnUnmarshal");
     VkResult vkResetEvent_VkResult_return = (VkResult)0;
     stream->read(&vkResetEvent_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkResetEvent");;
     return vkResetEvent_VkResult_return;
 }
@@ -3460,7 +3527,7 @@ VkResult VkEncoder::vkCreateQueryPool(
     const VkAllocationCallbacks* pAllocator,
     VkQueryPool* pQueryPool)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateQueryPool encode");
     mImpl->log("start vkCreateQueryPool");
     auto stream = mImpl->stream();
@@ -3540,9 +3607,9 @@ VkResult VkEncoder::vkCreateQueryPool(
     AEMU_SCOPED_TRACE("vkCreateQueryPool returnUnmarshal");
     VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
     stream->read(&vkCreateQueryPool_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateQueryPool");;
     return vkCreateQueryPool_VkResult_return;
 }
@@ -3552,7 +3619,7 @@ void VkEncoder::vkDestroyQueryPool(
     VkQueryPool queryPool,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyQueryPool encode");
     mImpl->log("start vkDestroyQueryPool");
     auto stream = mImpl->stream();
@@ -3613,6 +3680,9 @@ void VkEncoder::vkDestroyQueryPool(
     AEMU_SCOPED_TRACE("vkDestroyQueryPool readParams");
     AEMU_SCOPED_TRACE("vkDestroyQueryPool returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkQueryPool((VkQueryPool*)&queryPool);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyQueryPool");;
 }
 
@@ -3626,7 +3696,7 @@ VkResult VkEncoder::vkGetQueryPoolResults(
     VkDeviceSize stride,
     VkQueryResultFlags flags)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetQueryPoolResults encode");
     mImpl->log("start vkGetQueryPoolResults");
     auto stream = mImpl->stream();
@@ -3687,9 +3757,9 @@ VkResult VkEncoder::vkGetQueryPoolResults(
     AEMU_SCOPED_TRACE("vkGetQueryPoolResults returnUnmarshal");
     VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
     stream->read(&vkGetQueryPoolResults_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetQueryPoolResults");;
     return vkGetQueryPoolResults_VkResult_return;
 }
@@ -3700,7 +3770,7 @@ VkResult VkEncoder::vkCreateBuffer(
     const VkAllocationCallbacks* pAllocator,
     VkBuffer* pBuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateBuffer encode");
     mImpl->log("start vkCreateBuffer");
     auto stream = mImpl->stream();
@@ -3780,9 +3850,9 @@ VkResult VkEncoder::vkCreateBuffer(
     AEMU_SCOPED_TRACE("vkCreateBuffer returnUnmarshal");
     VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkCreateBuffer_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateBuffer");;
     return vkCreateBuffer_VkResult_return;
 }
@@ -3792,7 +3862,7 @@ void VkEncoder::vkDestroyBuffer(
     VkBuffer buffer,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyBuffer encode");
     mImpl->log("start vkDestroyBuffer");
     auto stream = mImpl->stream();
@@ -3853,6 +3923,9 @@ void VkEncoder::vkDestroyBuffer(
     AEMU_SCOPED_TRACE("vkDestroyBuffer readParams");
     AEMU_SCOPED_TRACE("vkDestroyBuffer returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkBuffer((VkBuffer*)&buffer);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyBuffer");;
 }
 
@@ -3862,7 +3935,7 @@ VkResult VkEncoder::vkCreateBufferView(
     const VkAllocationCallbacks* pAllocator,
     VkBufferView* pView)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateBufferView encode");
     mImpl->log("start vkCreateBufferView");
     auto stream = mImpl->stream();
@@ -3942,9 +4015,9 @@ VkResult VkEncoder::vkCreateBufferView(
     AEMU_SCOPED_TRACE("vkCreateBufferView returnUnmarshal");
     VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
     stream->read(&vkCreateBufferView_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateBufferView");;
     return vkCreateBufferView_VkResult_return;
 }
@@ -3954,7 +4027,7 @@ void VkEncoder::vkDestroyBufferView(
     VkBufferView bufferView,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyBufferView encode");
     mImpl->log("start vkDestroyBufferView");
     auto stream = mImpl->stream();
@@ -4015,6 +4088,9 @@ void VkEncoder::vkDestroyBufferView(
     AEMU_SCOPED_TRACE("vkDestroyBufferView readParams");
     AEMU_SCOPED_TRACE("vkDestroyBufferView returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkBufferView((VkBufferView*)&bufferView);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyBufferView");;
 }
 
@@ -4024,7 +4100,7 @@ VkResult VkEncoder::vkCreateImage(
     const VkAllocationCallbacks* pAllocator,
     VkImage* pImage)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateImage encode");
     mImpl->log("start vkCreateImage");
     auto stream = mImpl->stream();
@@ -4105,9 +4181,9 @@ VkResult VkEncoder::vkCreateImage(
     AEMU_SCOPED_TRACE("vkCreateImage returnUnmarshal");
     VkResult vkCreateImage_VkResult_return = (VkResult)0;
     stream->read(&vkCreateImage_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateImage");;
     return vkCreateImage_VkResult_return;
 }
@@ -4117,7 +4193,7 @@ void VkEncoder::vkDestroyImage(
     VkImage image,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyImage encode");
     mImpl->log("start vkDestroyImage");
     auto stream = mImpl->stream();
@@ -4178,6 +4254,9 @@ void VkEncoder::vkDestroyImage(
     AEMU_SCOPED_TRACE("vkDestroyImage readParams");
     AEMU_SCOPED_TRACE("vkDestroyImage returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkImage((VkImage*)&image);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyImage");;
 }
 
@@ -4187,7 +4266,7 @@ void VkEncoder::vkGetImageSubresourceLayout(
     const VkImageSubresource* pSubresource,
     VkSubresourceLayout* pLayout)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout encode");
     mImpl->log("start vkGetImageSubresourceLayout");
     auto stream = mImpl->stream();
@@ -4241,6 +4320,9 @@ void VkEncoder::vkGetImageSubresourceLayout(
         transform_fromhost_VkSubresourceLayout(mImpl->resources(), (VkSubresourceLayout*)(pLayout));
     }
     AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetImageSubresourceLayout");;
 }
 
@@ -4250,7 +4332,7 @@ VkResult VkEncoder::vkCreateImageView(
     const VkAllocationCallbacks* pAllocator,
     VkImageView* pView)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateImageView encode");
     mImpl->log("start vkCreateImageView");
     auto stream = mImpl->stream();
@@ -4330,9 +4412,9 @@ VkResult VkEncoder::vkCreateImageView(
     AEMU_SCOPED_TRACE("vkCreateImageView returnUnmarshal");
     VkResult vkCreateImageView_VkResult_return = (VkResult)0;
     stream->read(&vkCreateImageView_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateImageView");;
     return vkCreateImageView_VkResult_return;
 }
@@ -4342,7 +4424,7 @@ void VkEncoder::vkDestroyImageView(
     VkImageView imageView,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyImageView encode");
     mImpl->log("start vkDestroyImageView");
     auto stream = mImpl->stream();
@@ -4403,6 +4485,9 @@ void VkEncoder::vkDestroyImageView(
     AEMU_SCOPED_TRACE("vkDestroyImageView readParams");
     AEMU_SCOPED_TRACE("vkDestroyImageView returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkImageView((VkImageView*)&imageView);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyImageView");;
 }
 
@@ -4412,7 +4497,7 @@ VkResult VkEncoder::vkCreateShaderModule(
     const VkAllocationCallbacks* pAllocator,
     VkShaderModule* pShaderModule)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateShaderModule encode");
     mImpl->log("start vkCreateShaderModule");
     auto stream = mImpl->stream();
@@ -4492,9 +4577,9 @@ VkResult VkEncoder::vkCreateShaderModule(
     AEMU_SCOPED_TRACE("vkCreateShaderModule returnUnmarshal");
     VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
     stream->read(&vkCreateShaderModule_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateShaderModule");;
     return vkCreateShaderModule_VkResult_return;
 }
@@ -4504,7 +4589,7 @@ void VkEncoder::vkDestroyShaderModule(
     VkShaderModule shaderModule,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyShaderModule encode");
     mImpl->log("start vkDestroyShaderModule");
     auto stream = mImpl->stream();
@@ -4565,6 +4650,9 @@ void VkEncoder::vkDestroyShaderModule(
     AEMU_SCOPED_TRACE("vkDestroyShaderModule readParams");
     AEMU_SCOPED_TRACE("vkDestroyShaderModule returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkShaderModule((VkShaderModule*)&shaderModule);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyShaderModule");;
 }
 
@@ -4574,7 +4662,7 @@ VkResult VkEncoder::vkCreatePipelineCache(
     const VkAllocationCallbacks* pAllocator,
     VkPipelineCache* pPipelineCache)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreatePipelineCache encode");
     mImpl->log("start vkCreatePipelineCache");
     auto stream = mImpl->stream();
@@ -4654,9 +4742,9 @@ VkResult VkEncoder::vkCreatePipelineCache(
     AEMU_SCOPED_TRACE("vkCreatePipelineCache returnUnmarshal");
     VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
     stream->read(&vkCreatePipelineCache_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreatePipelineCache");;
     return vkCreatePipelineCache_VkResult_return;
 }
@@ -4666,7 +4754,7 @@ void VkEncoder::vkDestroyPipelineCache(
     VkPipelineCache pipelineCache,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyPipelineCache encode");
     mImpl->log("start vkDestroyPipelineCache");
     auto stream = mImpl->stream();
@@ -4727,6 +4815,9 @@ void VkEncoder::vkDestroyPipelineCache(
     AEMU_SCOPED_TRACE("vkDestroyPipelineCache readParams");
     AEMU_SCOPED_TRACE("vkDestroyPipelineCache returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkPipelineCache((VkPipelineCache*)&pipelineCache);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyPipelineCache");;
 }
 
@@ -4736,7 +4827,7 @@ VkResult VkEncoder::vkGetPipelineCacheData(
     size_t* pDataSize,
     void* pData)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPipelineCacheData encode");
     mImpl->log("start vkGetPipelineCacheData");
     auto stream = mImpl->stream();
@@ -4824,9 +4915,9 @@ VkResult VkEncoder::vkGetPipelineCacheData(
     AEMU_SCOPED_TRACE("vkGetPipelineCacheData returnUnmarshal");
     VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
     stream->read(&vkGetPipelineCacheData_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPipelineCacheData");;
     return vkGetPipelineCacheData_VkResult_return;
 }
@@ -4837,7 +4928,7 @@ VkResult VkEncoder::vkMergePipelineCaches(
     uint32_t srcCacheCount,
     const VkPipelineCache* pSrcCaches)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkMergePipelineCaches encode");
     mImpl->log("start vkMergePipelineCaches");
     auto stream = mImpl->stream();
@@ -4897,9 +4988,9 @@ VkResult VkEncoder::vkMergePipelineCaches(
     AEMU_SCOPED_TRACE("vkMergePipelineCaches returnUnmarshal");
     VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
     stream->read(&vkMergePipelineCaches_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkMergePipelineCaches");;
     return vkMergePipelineCaches_VkResult_return;
 }
@@ -4912,7 +5003,7 @@ VkResult VkEncoder::vkCreateGraphicsPipelines(
     const VkAllocationCallbacks* pAllocator,
     VkPipeline* pPipelines)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines encode");
     mImpl->log("start vkCreateGraphicsPipelines");
     auto stream = mImpl->stream();
@@ -5028,9 +5119,9 @@ VkResult VkEncoder::vkCreateGraphicsPipelines(
     AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines returnUnmarshal");
     VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
     stream->read(&vkCreateGraphicsPipelines_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateGraphicsPipelines");;
     return vkCreateGraphicsPipelines_VkResult_return;
 }
@@ -5043,7 +5134,7 @@ VkResult VkEncoder::vkCreateComputePipelines(
     const VkAllocationCallbacks* pAllocator,
     VkPipeline* pPipelines)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateComputePipelines encode");
     mImpl->log("start vkCreateComputePipelines");
     auto stream = mImpl->stream();
@@ -5159,9 +5250,9 @@ VkResult VkEncoder::vkCreateComputePipelines(
     AEMU_SCOPED_TRACE("vkCreateComputePipelines returnUnmarshal");
     VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
     stream->read(&vkCreateComputePipelines_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateComputePipelines");;
     return vkCreateComputePipelines_VkResult_return;
 }
@@ -5171,7 +5262,7 @@ void VkEncoder::vkDestroyPipeline(
     VkPipeline pipeline,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyPipeline encode");
     mImpl->log("start vkDestroyPipeline");
     auto stream = mImpl->stream();
@@ -5232,6 +5323,9 @@ void VkEncoder::vkDestroyPipeline(
     AEMU_SCOPED_TRACE("vkDestroyPipeline readParams");
     AEMU_SCOPED_TRACE("vkDestroyPipeline returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkPipeline((VkPipeline*)&pipeline);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyPipeline");;
 }
 
@@ -5241,7 +5335,7 @@ VkResult VkEncoder::vkCreatePipelineLayout(
     const VkAllocationCallbacks* pAllocator,
     VkPipelineLayout* pPipelineLayout)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreatePipelineLayout encode");
     mImpl->log("start vkCreatePipelineLayout");
     auto stream = mImpl->stream();
@@ -5321,9 +5415,9 @@ VkResult VkEncoder::vkCreatePipelineLayout(
     AEMU_SCOPED_TRACE("vkCreatePipelineLayout returnUnmarshal");
     VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
     stream->read(&vkCreatePipelineLayout_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreatePipelineLayout");;
     return vkCreatePipelineLayout_VkResult_return;
 }
@@ -5333,7 +5427,7 @@ void VkEncoder::vkDestroyPipelineLayout(
     VkPipelineLayout pipelineLayout,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyPipelineLayout encode");
     mImpl->log("start vkDestroyPipelineLayout");
     auto stream = mImpl->stream();
@@ -5394,6 +5488,9 @@ void VkEncoder::vkDestroyPipelineLayout(
     AEMU_SCOPED_TRACE("vkDestroyPipelineLayout readParams");
     AEMU_SCOPED_TRACE("vkDestroyPipelineLayout returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkPipelineLayout((VkPipelineLayout*)&pipelineLayout);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyPipelineLayout");;
 }
 
@@ -5403,7 +5500,7 @@ VkResult VkEncoder::vkCreateSampler(
     const VkAllocationCallbacks* pAllocator,
     VkSampler* pSampler)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateSampler encode");
     mImpl->log("start vkCreateSampler");
     auto stream = mImpl->stream();
@@ -5483,9 +5580,9 @@ VkResult VkEncoder::vkCreateSampler(
     AEMU_SCOPED_TRACE("vkCreateSampler returnUnmarshal");
     VkResult vkCreateSampler_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSampler_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateSampler");;
     return vkCreateSampler_VkResult_return;
 }
@@ -5495,7 +5592,7 @@ void VkEncoder::vkDestroySampler(
     VkSampler sampler,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroySampler encode");
     mImpl->log("start vkDestroySampler");
     auto stream = mImpl->stream();
@@ -5556,6 +5653,9 @@ void VkEncoder::vkDestroySampler(
     AEMU_SCOPED_TRACE("vkDestroySampler readParams");
     AEMU_SCOPED_TRACE("vkDestroySampler returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSampler((VkSampler*)&sampler);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroySampler");;
 }
 
@@ -5565,7 +5665,7 @@ VkResult VkEncoder::vkCreateDescriptorSetLayout(
     const VkAllocationCallbacks* pAllocator,
     VkDescriptorSetLayout* pSetLayout)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout encode");
     mImpl->log("start vkCreateDescriptorSetLayout");
     auto stream = mImpl->stream();
@@ -5645,9 +5745,9 @@ VkResult VkEncoder::vkCreateDescriptorSetLayout(
     AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout returnUnmarshal");
     VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorSetLayout_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateDescriptorSetLayout");;
     return vkCreateDescriptorSetLayout_VkResult_return;
 }
@@ -5657,7 +5757,7 @@ void VkEncoder::vkDestroyDescriptorSetLayout(
     VkDescriptorSetLayout descriptorSetLayout,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout encode");
     mImpl->log("start vkDestroyDescriptorSetLayout");
     auto stream = mImpl->stream();
@@ -5718,6 +5818,9 @@ void VkEncoder::vkDestroyDescriptorSetLayout(
     AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout readParams");
     AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&descriptorSetLayout);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyDescriptorSetLayout");;
 }
 
@@ -5727,7 +5830,7 @@ VkResult VkEncoder::vkCreateDescriptorPool(
     const VkAllocationCallbacks* pAllocator,
     VkDescriptorPool* pDescriptorPool)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateDescriptorPool encode");
     mImpl->log("start vkCreateDescriptorPool");
     auto stream = mImpl->stream();
@@ -5807,9 +5910,9 @@ VkResult VkEncoder::vkCreateDescriptorPool(
     AEMU_SCOPED_TRACE("vkCreateDescriptorPool returnUnmarshal");
     VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorPool_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateDescriptorPool");;
     return vkCreateDescriptorPool_VkResult_return;
 }
@@ -5819,7 +5922,7 @@ void VkEncoder::vkDestroyDescriptorPool(
     VkDescriptorPool descriptorPool,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyDescriptorPool encode");
     mImpl->log("start vkDestroyDescriptorPool");
     auto stream = mImpl->stream();
@@ -5880,6 +5983,9 @@ void VkEncoder::vkDestroyDescriptorPool(
     AEMU_SCOPED_TRACE("vkDestroyDescriptorPool readParams");
     AEMU_SCOPED_TRACE("vkDestroyDescriptorPool returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDescriptorPool((VkDescriptorPool*)&descriptorPool);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyDescriptorPool");;
 }
 
@@ -5888,7 +5994,7 @@ VkResult VkEncoder::vkResetDescriptorPool(
     VkDescriptorPool descriptorPool,
     VkDescriptorPoolResetFlags flags)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkResetDescriptorPool encode");
     mImpl->log("start vkResetDescriptorPool");
     auto stream = mImpl->stream();
@@ -5928,9 +6034,9 @@ VkResult VkEncoder::vkResetDescriptorPool(
     AEMU_SCOPED_TRACE("vkResetDescriptorPool returnUnmarshal");
     VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
     stream->read(&vkResetDescriptorPool_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkResetDescriptorPool");;
     return vkResetDescriptorPool_VkResult_return;
 }
@@ -5940,7 +6046,7 @@ VkResult VkEncoder::vkAllocateDescriptorSets(
     const VkDescriptorSetAllocateInfo* pAllocateInfo,
     VkDescriptorSet* pDescriptorSets)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkAllocateDescriptorSets encode");
     mImpl->log("start vkAllocateDescriptorSets");
     auto stream = mImpl->stream();
@@ -6006,9 +6112,9 @@ VkResult VkEncoder::vkAllocateDescriptorSets(
     AEMU_SCOPED_TRACE("vkAllocateDescriptorSets returnUnmarshal");
     VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
     stream->read(&vkAllocateDescriptorSets_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkAllocateDescriptorSets");;
     return vkAllocateDescriptorSets_VkResult_return;
 }
@@ -6019,7 +6125,7 @@ VkResult VkEncoder::vkFreeDescriptorSets(
     uint32_t descriptorSetCount,
     const VkDescriptorSet* pDescriptorSets)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkFreeDescriptorSets encode");
     mImpl->log("start vkFreeDescriptorSets");
     auto stream = mImpl->stream();
@@ -6091,13 +6197,13 @@ VkResult VkEncoder::vkFreeDescriptorSets(
     AEMU_SCOPED_TRACE("vkFreeDescriptorSets returnUnmarshal");
     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)));
     }
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkFreeDescriptorSets");;
     return vkFreeDescriptorSets_VkResult_return;
 }
@@ -6109,7 +6215,7 @@ void VkEncoder::vkUpdateDescriptorSets(
     uint32_t descriptorCopyCount,
     const VkCopyDescriptorSet* pDescriptorCopies)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSets encode");
     mImpl->log("start vkUpdateDescriptorSets");
     auto stream = mImpl->stream();
@@ -6193,6 +6299,9 @@ void VkEncoder::vkUpdateDescriptorSets(
     }
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSets readParams");
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSets returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkUpdateDescriptorSets");;
 }
 
@@ -6202,7 +6311,7 @@ VkResult VkEncoder::vkCreateFramebuffer(
     const VkAllocationCallbacks* pAllocator,
     VkFramebuffer* pFramebuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateFramebuffer encode");
     mImpl->log("start vkCreateFramebuffer");
     auto stream = mImpl->stream();
@@ -6282,9 +6391,9 @@ VkResult VkEncoder::vkCreateFramebuffer(
     AEMU_SCOPED_TRACE("vkCreateFramebuffer returnUnmarshal");
     VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
     stream->read(&vkCreateFramebuffer_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateFramebuffer");;
     return vkCreateFramebuffer_VkResult_return;
 }
@@ -6294,7 +6403,7 @@ void VkEncoder::vkDestroyFramebuffer(
     VkFramebuffer framebuffer,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyFramebuffer encode");
     mImpl->log("start vkDestroyFramebuffer");
     auto stream = mImpl->stream();
@@ -6355,6 +6464,9 @@ void VkEncoder::vkDestroyFramebuffer(
     AEMU_SCOPED_TRACE("vkDestroyFramebuffer readParams");
     AEMU_SCOPED_TRACE("vkDestroyFramebuffer returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkFramebuffer((VkFramebuffer*)&framebuffer);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyFramebuffer");;
 }
 
@@ -6364,7 +6476,7 @@ VkResult VkEncoder::vkCreateRenderPass(
     const VkAllocationCallbacks* pAllocator,
     VkRenderPass* pRenderPass)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateRenderPass encode");
     mImpl->log("start vkCreateRenderPass");
     auto stream = mImpl->stream();
@@ -6444,9 +6556,9 @@ VkResult VkEncoder::vkCreateRenderPass(
     AEMU_SCOPED_TRACE("vkCreateRenderPass returnUnmarshal");
     VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
     stream->read(&vkCreateRenderPass_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateRenderPass");;
     return vkCreateRenderPass_VkResult_return;
 }
@@ -6456,7 +6568,7 @@ void VkEncoder::vkDestroyRenderPass(
     VkRenderPass renderPass,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyRenderPass encode");
     mImpl->log("start vkDestroyRenderPass");
     auto stream = mImpl->stream();
@@ -6517,6 +6629,9 @@ void VkEncoder::vkDestroyRenderPass(
     AEMU_SCOPED_TRACE("vkDestroyRenderPass readParams");
     AEMU_SCOPED_TRACE("vkDestroyRenderPass returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkRenderPass((VkRenderPass*)&renderPass);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyRenderPass");;
 }
 
@@ -6525,7 +6640,7 @@ void VkEncoder::vkGetRenderAreaGranularity(
     VkRenderPass renderPass,
     VkExtent2D* pGranularity)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity encode");
     mImpl->log("start vkGetRenderAreaGranularity");
     auto stream = mImpl->stream();
@@ -6566,6 +6681,9 @@ void VkEncoder::vkGetRenderAreaGranularity(
         transform_fromhost_VkExtent2D(mImpl->resources(), (VkExtent2D*)(pGranularity));
     }
     AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetRenderAreaGranularity");;
 }
 
@@ -6575,7 +6693,7 @@ VkResult VkEncoder::vkCreateCommandPool(
     const VkAllocationCallbacks* pAllocator,
     VkCommandPool* pCommandPool)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateCommandPool encode");
     mImpl->log("start vkCreateCommandPool");
     auto stream = mImpl->stream();
@@ -6655,9 +6773,9 @@ VkResult VkEncoder::vkCreateCommandPool(
     AEMU_SCOPED_TRACE("vkCreateCommandPool returnUnmarshal");
     VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
     stream->read(&vkCreateCommandPool_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateCommandPool");;
     return vkCreateCommandPool_VkResult_return;
 }
@@ -6667,7 +6785,7 @@ void VkEncoder::vkDestroyCommandPool(
     VkCommandPool commandPool,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyCommandPool encode");
     mImpl->log("start vkDestroyCommandPool");
     auto stream = mImpl->stream();
@@ -6728,6 +6846,9 @@ void VkEncoder::vkDestroyCommandPool(
     AEMU_SCOPED_TRACE("vkDestroyCommandPool readParams");
     AEMU_SCOPED_TRACE("vkDestroyCommandPool returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkCommandPool((VkCommandPool*)&commandPool);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyCommandPool");;
 }
 
@@ -6736,7 +6857,7 @@ VkResult VkEncoder::vkResetCommandPool(
     VkCommandPool commandPool,
     VkCommandPoolResetFlags flags)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkResetCommandPool encode");
     mImpl->log("start vkResetCommandPool");
     auto stream = mImpl->stream();
@@ -6776,9 +6897,9 @@ VkResult VkEncoder::vkResetCommandPool(
     AEMU_SCOPED_TRACE("vkResetCommandPool returnUnmarshal");
     VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
     stream->read(&vkResetCommandPool_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkResetCommandPool");;
     return vkResetCommandPool_VkResult_return;
 }
@@ -6788,7 +6909,7 @@ VkResult VkEncoder::vkAllocateCommandBuffers(
     const VkCommandBufferAllocateInfo* pAllocateInfo,
     VkCommandBuffer* pCommandBuffers)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkAllocateCommandBuffers encode");
     mImpl->log("start vkAllocateCommandBuffers");
     auto stream = mImpl->stream();
@@ -6854,9 +6975,9 @@ VkResult VkEncoder::vkAllocateCommandBuffers(
     AEMU_SCOPED_TRACE("vkAllocateCommandBuffers returnUnmarshal");
     VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
     stream->read(&vkAllocateCommandBuffers_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkAllocateCommandBuffers");;
     return vkAllocateCommandBuffers_VkResult_return;
 }
@@ -6867,7 +6988,7 @@ void VkEncoder::vkFreeCommandBuffers(
     uint32_t commandBufferCount,
     const VkCommandBuffer* pCommandBuffers)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkFreeCommandBuffers encode");
     mImpl->log("start vkFreeCommandBuffers");
     auto stream = mImpl->stream();
@@ -6941,6 +7062,9 @@ void VkEncoder::vkFreeCommandBuffers(
     {
         resources->destroyMapping()->mapHandles_VkCommandBuffer((VkCommandBuffer*)pCommandBuffers, ((commandBufferCount)));
     }
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkFreeCommandBuffers");;
 }
 
@@ -6948,7 +7072,7 @@ VkResult VkEncoder::vkBeginCommandBuffer(
     VkCommandBuffer commandBuffer,
     const VkCommandBufferBeginInfo* pBeginInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkBeginCommandBuffer encode");
     mImpl->log("start vkBeginCommandBuffer");
     auto stream = mImpl->stream();
@@ -6989,9 +7113,9 @@ VkResult VkEncoder::vkBeginCommandBuffer(
     AEMU_SCOPED_TRACE("vkBeginCommandBuffer returnUnmarshal");
     VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkBeginCommandBuffer_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkBeginCommandBuffer");;
     return vkBeginCommandBuffer_VkResult_return;
 }
@@ -6999,7 +7123,7 @@ VkResult VkEncoder::vkBeginCommandBuffer(
 VkResult VkEncoder::vkEndCommandBuffer(
     VkCommandBuffer commandBuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkEndCommandBuffer encode");
     mImpl->log("start vkEndCommandBuffer");
     auto stream = mImpl->stream();
@@ -7027,9 +7151,9 @@ VkResult VkEncoder::vkEndCommandBuffer(
     AEMU_SCOPED_TRACE("vkEndCommandBuffer returnUnmarshal");
     VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkEndCommandBuffer_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkEndCommandBuffer");;
     return vkEndCommandBuffer_VkResult_return;
 }
@@ -7038,7 +7162,7 @@ VkResult VkEncoder::vkResetCommandBuffer(
     VkCommandBuffer commandBuffer,
     VkCommandBufferResetFlags flags)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkResetCommandBuffer encode");
     mImpl->log("start vkResetCommandBuffer");
     auto stream = mImpl->stream();
@@ -7070,9 +7194,9 @@ VkResult VkEncoder::vkResetCommandBuffer(
     AEMU_SCOPED_TRACE("vkResetCommandBuffer returnUnmarshal");
     VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkResetCommandBuffer_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkResetCommandBuffer");;
     return vkResetCommandBuffer_VkResult_return;
 }
@@ -7082,7 +7206,7 @@ void VkEncoder::vkCmdBindPipeline(
     VkPipelineBindPoint pipelineBindPoint,
     VkPipeline pipeline)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdBindPipeline encode");
     mImpl->log("start vkCmdBindPipeline");
     auto stream = mImpl->stream();
@@ -7120,6 +7244,9 @@ void VkEncoder::vkCmdBindPipeline(
     stream->write((uint64_t*)&cgen_var_508, 1 * 8);
     AEMU_SCOPED_TRACE("vkCmdBindPipeline readParams");
     AEMU_SCOPED_TRACE("vkCmdBindPipeline returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdBindPipeline");;
 }
 
@@ -7129,7 +7256,7 @@ void VkEncoder::vkCmdSetViewport(
     uint32_t viewportCount,
     const VkViewport* pViewports)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetViewport encode");
     mImpl->log("start vkCmdSetViewport");
     auto stream = mImpl->stream();
@@ -7188,6 +7315,9 @@ void VkEncoder::vkCmdSetViewport(
     }
     AEMU_SCOPED_TRACE("vkCmdSetViewport readParams");
     AEMU_SCOPED_TRACE("vkCmdSetViewport returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetViewport");;
 }
 
@@ -7197,7 +7327,7 @@ void VkEncoder::vkCmdSetScissor(
     uint32_t scissorCount,
     const VkRect2D* pScissors)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetScissor encode");
     mImpl->log("start vkCmdSetScissor");
     auto stream = mImpl->stream();
@@ -7256,6 +7386,9 @@ void VkEncoder::vkCmdSetScissor(
     }
     AEMU_SCOPED_TRACE("vkCmdSetScissor readParams");
     AEMU_SCOPED_TRACE("vkCmdSetScissor returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetScissor");;
 }
 
@@ -7263,7 +7396,7 @@ void VkEncoder::vkCmdSetLineWidth(
     VkCommandBuffer commandBuffer,
     float lineWidth)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetLineWidth encode");
     mImpl->log("start vkCmdSetLineWidth");
     auto stream = mImpl->stream();
@@ -7293,6 +7426,9 @@ void VkEncoder::vkCmdSetLineWidth(
     stream->write((float*)&local_lineWidth, sizeof(float));
     AEMU_SCOPED_TRACE("vkCmdSetLineWidth readParams");
     AEMU_SCOPED_TRACE("vkCmdSetLineWidth returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetLineWidth");;
 }
 
@@ -7302,7 +7438,7 @@ void VkEncoder::vkCmdSetDepthBias(
     float depthBiasClamp,
     float depthBiasSlopeFactor)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetDepthBias encode");
     mImpl->log("start vkCmdSetDepthBias");
     auto stream = mImpl->stream();
@@ -7340,6 +7476,9 @@ void VkEncoder::vkCmdSetDepthBias(
     stream->write((float*)&local_depthBiasSlopeFactor, sizeof(float));
     AEMU_SCOPED_TRACE("vkCmdSetDepthBias readParams");
     AEMU_SCOPED_TRACE("vkCmdSetDepthBias returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetDepthBias");;
 }
 
@@ -7347,7 +7486,7 @@ void VkEncoder::vkCmdSetBlendConstants(
     VkCommandBuffer commandBuffer,
     const float blendConstants[4])
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetBlendConstants encode");
     mImpl->log("start vkCmdSetBlendConstants");
     auto stream = mImpl->stream();
@@ -7377,6 +7516,9 @@ void VkEncoder::vkCmdSetBlendConstants(
     stream->write((float*)local_blendConstants, 4 * sizeof(float));
     AEMU_SCOPED_TRACE("vkCmdSetBlendConstants readParams");
     AEMU_SCOPED_TRACE("vkCmdSetBlendConstants returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetBlendConstants");;
 }
 
@@ -7385,7 +7527,7 @@ void VkEncoder::vkCmdSetDepthBounds(
     float minDepthBounds,
     float maxDepthBounds)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetDepthBounds encode");
     mImpl->log("start vkCmdSetDepthBounds");
     auto stream = mImpl->stream();
@@ -7419,6 +7561,9 @@ void VkEncoder::vkCmdSetDepthBounds(
     stream->write((float*)&local_maxDepthBounds, sizeof(float));
     AEMU_SCOPED_TRACE("vkCmdSetDepthBounds readParams");
     AEMU_SCOPED_TRACE("vkCmdSetDepthBounds returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetDepthBounds");;
 }
 
@@ -7427,7 +7572,7 @@ void VkEncoder::vkCmdSetStencilCompareMask(
     VkStencilFaceFlags faceMask,
     uint32_t compareMask)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask encode");
     mImpl->log("start vkCmdSetStencilCompareMask");
     auto stream = mImpl->stream();
@@ -7461,6 +7606,9 @@ void VkEncoder::vkCmdSetStencilCompareMask(
     stream->write((uint32_t*)&local_compareMask, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask readParams");
     AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetStencilCompareMask");;
 }
 
@@ -7469,7 +7617,7 @@ void VkEncoder::vkCmdSetStencilWriteMask(
     VkStencilFaceFlags faceMask,
     uint32_t writeMask)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask encode");
     mImpl->log("start vkCmdSetStencilWriteMask");
     auto stream = mImpl->stream();
@@ -7503,6 +7651,9 @@ void VkEncoder::vkCmdSetStencilWriteMask(
     stream->write((uint32_t*)&local_writeMask, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask readParams");
     AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetStencilWriteMask");;
 }
 
@@ -7511,7 +7662,7 @@ void VkEncoder::vkCmdSetStencilReference(
     VkStencilFaceFlags faceMask,
     uint32_t reference)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetStencilReference encode");
     mImpl->log("start vkCmdSetStencilReference");
     auto stream = mImpl->stream();
@@ -7545,6 +7696,9 @@ void VkEncoder::vkCmdSetStencilReference(
     stream->write((uint32_t*)&local_reference, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdSetStencilReference readParams");
     AEMU_SCOPED_TRACE("vkCmdSetStencilReference returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetStencilReference");;
 }
 
@@ -7558,7 +7712,7 @@ void VkEncoder::vkCmdBindDescriptorSets(
     uint32_t dynamicOffsetCount,
     const uint32_t* pDynamicOffsets)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets encode");
     mImpl->log("start vkCmdBindDescriptorSets");
     auto stream = mImpl->stream();
@@ -7636,6 +7790,9 @@ void VkEncoder::vkCmdBindDescriptorSets(
     stream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets readParams");
     AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdBindDescriptorSets");;
 }
 
@@ -7645,7 +7802,7 @@ void VkEncoder::vkCmdBindIndexBuffer(
     VkDeviceSize offset,
     VkIndexType indexType)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer encode");
     mImpl->log("start vkCmdBindIndexBuffer");
     auto stream = mImpl->stream();
@@ -7687,6 +7844,9 @@ void VkEncoder::vkCmdBindIndexBuffer(
     stream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType));
     AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer readParams");
     AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdBindIndexBuffer");;
 }
 
@@ -7697,7 +7857,7 @@ void VkEncoder::vkCmdBindVertexBuffers(
     const VkBuffer* pBuffers,
     const VkDeviceSize* pOffsets)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers encode");
     mImpl->log("start vkCmdBindVertexBuffers");
     auto stream = mImpl->stream();
@@ -7759,6 +7919,9 @@ void VkEncoder::vkCmdBindVertexBuffers(
     stream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
     AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers readParams");
     AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdBindVertexBuffers");;
 }
 
@@ -7769,7 +7932,7 @@ void VkEncoder::vkCmdDraw(
     uint32_t firstVertex,
     uint32_t firstInstance)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDraw encode");
     mImpl->log("start vkCmdDraw");
     auto stream = mImpl->stream();
@@ -7811,6 +7974,9 @@ void VkEncoder::vkCmdDraw(
     stream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDraw readParams");
     AEMU_SCOPED_TRACE("vkCmdDraw returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDraw");;
 }
 
@@ -7822,7 +7988,7 @@ void VkEncoder::vkCmdDrawIndexed(
     int32_t vertexOffset,
     uint32_t firstInstance)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDrawIndexed encode");
     mImpl->log("start vkCmdDrawIndexed");
     auto stream = mImpl->stream();
@@ -7868,6 +8034,9 @@ void VkEncoder::vkCmdDrawIndexed(
     stream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDrawIndexed readParams");
     AEMU_SCOPED_TRACE("vkCmdDrawIndexed returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDrawIndexed");;
 }
 
@@ -7878,7 +8047,7 @@ void VkEncoder::vkCmdDrawIndirect(
     uint32_t drawCount,
     uint32_t stride)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDrawIndirect encode");
     mImpl->log("start vkCmdDrawIndirect");
     auto stream = mImpl->stream();
@@ -7924,6 +8093,9 @@ void VkEncoder::vkCmdDrawIndirect(
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDrawIndirect readParams");
     AEMU_SCOPED_TRACE("vkCmdDrawIndirect returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDrawIndirect");;
 }
 
@@ -7934,7 +8106,7 @@ void VkEncoder::vkCmdDrawIndexedIndirect(
     uint32_t drawCount,
     uint32_t stride)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect encode");
     mImpl->log("start vkCmdDrawIndexedIndirect");
     auto stream = mImpl->stream();
@@ -7980,6 +8152,9 @@ void VkEncoder::vkCmdDrawIndexedIndirect(
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect readParams");
     AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDrawIndexedIndirect");;
 }
 
@@ -7989,7 +8164,7 @@ void VkEncoder::vkCmdDispatch(
     uint32_t groupCountY,
     uint32_t groupCountZ)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDispatch encode");
     mImpl->log("start vkCmdDispatch");
     auto stream = mImpl->stream();
@@ -8027,6 +8202,9 @@ void VkEncoder::vkCmdDispatch(
     stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDispatch readParams");
     AEMU_SCOPED_TRACE("vkCmdDispatch returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDispatch");;
 }
 
@@ -8035,7 +8213,7 @@ void VkEncoder::vkCmdDispatchIndirect(
     VkBuffer buffer,
     VkDeviceSize offset)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDispatchIndirect encode");
     mImpl->log("start vkCmdDispatchIndirect");
     auto stream = mImpl->stream();
@@ -8073,6 +8251,9 @@ void VkEncoder::vkCmdDispatchIndirect(
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
     AEMU_SCOPED_TRACE("vkCmdDispatchIndirect readParams");
     AEMU_SCOPED_TRACE("vkCmdDispatchIndirect returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDispatchIndirect");;
 }
 
@@ -8083,7 +8264,7 @@ void VkEncoder::vkCmdCopyBuffer(
     uint32_t regionCount,
     const VkBufferCopy* pRegions)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdCopyBuffer encode");
     mImpl->log("start vkCmdCopyBuffer");
     auto stream = mImpl->stream();
@@ -8154,6 +8335,9 @@ void VkEncoder::vkCmdCopyBuffer(
     }
     AEMU_SCOPED_TRACE("vkCmdCopyBuffer readParams");
     AEMU_SCOPED_TRACE("vkCmdCopyBuffer returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdCopyBuffer");;
 }
 
@@ -8166,7 +8350,7 @@ void VkEncoder::vkCmdCopyImage(
     uint32_t regionCount,
     const VkImageCopy* pRegions)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdCopyImage encode");
     mImpl->log("start vkCmdCopyImage");
     auto stream = mImpl->stream();
@@ -8245,6 +8429,9 @@ void VkEncoder::vkCmdCopyImage(
     }
     AEMU_SCOPED_TRACE("vkCmdCopyImage readParams");
     AEMU_SCOPED_TRACE("vkCmdCopyImage returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdCopyImage");;
 }
 
@@ -8258,7 +8445,7 @@ void VkEncoder::vkCmdBlitImage(
     const VkImageBlit* pRegions,
     VkFilter filter)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdBlitImage encode");
     mImpl->log("start vkCmdBlitImage");
     auto stream = mImpl->stream();
@@ -8341,6 +8528,9 @@ void VkEncoder::vkCmdBlitImage(
     stream->write((VkFilter*)&local_filter, sizeof(VkFilter));
     AEMU_SCOPED_TRACE("vkCmdBlitImage readParams");
     AEMU_SCOPED_TRACE("vkCmdBlitImage returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdBlitImage");;
 }
 
@@ -8352,7 +8542,7 @@ void VkEncoder::vkCmdCopyBufferToImage(
     uint32_t regionCount,
     const VkBufferImageCopy* pRegions)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage encode");
     mImpl->log("start vkCmdCopyBufferToImage");
     auto stream = mImpl->stream();
@@ -8427,6 +8617,9 @@ void VkEncoder::vkCmdCopyBufferToImage(
     }
     AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage readParams");
     AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdCopyBufferToImage");;
 }
 
@@ -8438,7 +8631,7 @@ void VkEncoder::vkCmdCopyImageToBuffer(
     uint32_t regionCount,
     const VkBufferImageCopy* pRegions)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer encode");
     mImpl->log("start vkCmdCopyImageToBuffer");
     auto stream = mImpl->stream();
@@ -8513,6 +8706,9 @@ void VkEncoder::vkCmdCopyImageToBuffer(
     }
     AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer readParams");
     AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdCopyImageToBuffer");;
 }
 
@@ -8523,7 +8719,7 @@ void VkEncoder::vkCmdUpdateBuffer(
     VkDeviceSize dataSize,
     const void* pData)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdUpdateBuffer encode");
     mImpl->log("start vkCmdUpdateBuffer");
     auto stream = mImpl->stream();
@@ -8573,6 +8769,9 @@ void VkEncoder::vkCmdUpdateBuffer(
     stream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t));
     AEMU_SCOPED_TRACE("vkCmdUpdateBuffer readParams");
     AEMU_SCOPED_TRACE("vkCmdUpdateBuffer returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdUpdateBuffer");;
 }
 
@@ -8583,7 +8782,7 @@ void VkEncoder::vkCmdFillBuffer(
     VkDeviceSize size,
     uint32_t data)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdFillBuffer encode");
     mImpl->log("start vkCmdFillBuffer");
     auto stream = mImpl->stream();
@@ -8629,6 +8828,9 @@ void VkEncoder::vkCmdFillBuffer(
     stream->write((uint32_t*)&local_data, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdFillBuffer readParams");
     AEMU_SCOPED_TRACE("vkCmdFillBuffer returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdFillBuffer");;
 }
 
@@ -8640,7 +8842,7 @@ void VkEncoder::vkCmdClearColorImage(
     uint32_t rangeCount,
     const VkImageSubresourceRange* pRanges)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdClearColorImage encode");
     mImpl->log("start vkCmdClearColorImage");
     auto stream = mImpl->stream();
@@ -8720,6 +8922,9 @@ void VkEncoder::vkCmdClearColorImage(
     }
     AEMU_SCOPED_TRACE("vkCmdClearColorImage readParams");
     AEMU_SCOPED_TRACE("vkCmdClearColorImage returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdClearColorImage");;
 }
 
@@ -8731,7 +8936,7 @@ void VkEncoder::vkCmdClearDepthStencilImage(
     uint32_t rangeCount,
     const VkImageSubresourceRange* pRanges)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage encode");
     mImpl->log("start vkCmdClearDepthStencilImage");
     auto stream = mImpl->stream();
@@ -8811,6 +9016,9 @@ void VkEncoder::vkCmdClearDepthStencilImage(
     }
     AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage readParams");
     AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdClearDepthStencilImage");;
 }
 
@@ -8821,7 +9029,7 @@ void VkEncoder::vkCmdClearAttachments(
     uint32_t rectCount,
     const VkClearRect* pRects)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdClearAttachments encode");
     mImpl->log("start vkCmdClearAttachments");
     auto stream = mImpl->stream();
@@ -8905,6 +9113,9 @@ void VkEncoder::vkCmdClearAttachments(
     }
     AEMU_SCOPED_TRACE("vkCmdClearAttachments readParams");
     AEMU_SCOPED_TRACE("vkCmdClearAttachments returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdClearAttachments");;
 }
 
@@ -8917,7 +9128,7 @@ void VkEncoder::vkCmdResolveImage(
     uint32_t regionCount,
     const VkImageResolve* pRegions)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdResolveImage encode");
     mImpl->log("start vkCmdResolveImage");
     auto stream = mImpl->stream();
@@ -8996,6 +9207,9 @@ void VkEncoder::vkCmdResolveImage(
     }
     AEMU_SCOPED_TRACE("vkCmdResolveImage readParams");
     AEMU_SCOPED_TRACE("vkCmdResolveImage returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdResolveImage");;
 }
 
@@ -9004,7 +9218,7 @@ void VkEncoder::vkCmdSetEvent(
     VkEvent event,
     VkPipelineStageFlags stageMask)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetEvent encode");
     mImpl->log("start vkCmdSetEvent");
     auto stream = mImpl->stream();
@@ -9042,6 +9256,9 @@ void VkEncoder::vkCmdSetEvent(
     stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
     AEMU_SCOPED_TRACE("vkCmdSetEvent readParams");
     AEMU_SCOPED_TRACE("vkCmdSetEvent returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetEvent");;
 }
 
@@ -9050,7 +9267,7 @@ void VkEncoder::vkCmdResetEvent(
     VkEvent event,
     VkPipelineStageFlags stageMask)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdResetEvent encode");
     mImpl->log("start vkCmdResetEvent");
     auto stream = mImpl->stream();
@@ -9088,6 +9305,9 @@ void VkEncoder::vkCmdResetEvent(
     stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
     AEMU_SCOPED_TRACE("vkCmdResetEvent readParams");
     AEMU_SCOPED_TRACE("vkCmdResetEvent returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdResetEvent");;
 }
 
@@ -9104,7 +9324,7 @@ void VkEncoder::vkCmdWaitEvents(
     uint32_t imageMemoryBarrierCount,
     const VkImageMemoryBarrier* pImageMemoryBarriers)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdWaitEvents encode");
     mImpl->log("start vkCmdWaitEvents");
     auto stream = mImpl->stream();
@@ -9249,6 +9469,9 @@ void VkEncoder::vkCmdWaitEvents(
     }
     AEMU_SCOPED_TRACE("vkCmdWaitEvents readParams");
     AEMU_SCOPED_TRACE("vkCmdWaitEvents returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdWaitEvents");;
 }
 
@@ -9264,7 +9487,7 @@ void VkEncoder::vkCmdPipelineBarrier(
     uint32_t imageMemoryBarrierCount,
     const VkImageMemoryBarrier* pImageMemoryBarriers)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdPipelineBarrier encode");
     mImpl->log("start vkCmdPipelineBarrier");
     auto stream = mImpl->stream();
@@ -9389,6 +9612,9 @@ void VkEncoder::vkCmdPipelineBarrier(
     }
     AEMU_SCOPED_TRACE("vkCmdPipelineBarrier readParams");
     AEMU_SCOPED_TRACE("vkCmdPipelineBarrier returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdPipelineBarrier");;
 }
 
@@ -9398,7 +9624,7 @@ void VkEncoder::vkCmdBeginQuery(
     uint32_t query,
     VkQueryControlFlags flags)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdBeginQuery encode");
     mImpl->log("start vkCmdBeginQuery");
     auto stream = mImpl->stream();
@@ -9440,6 +9666,9 @@ void VkEncoder::vkCmdBeginQuery(
     stream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
     AEMU_SCOPED_TRACE("vkCmdBeginQuery readParams");
     AEMU_SCOPED_TRACE("vkCmdBeginQuery returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdBeginQuery");;
 }
 
@@ -9448,7 +9677,7 @@ void VkEncoder::vkCmdEndQuery(
     VkQueryPool queryPool,
     uint32_t query)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdEndQuery encode");
     mImpl->log("start vkCmdEndQuery");
     auto stream = mImpl->stream();
@@ -9486,6 +9715,9 @@ void VkEncoder::vkCmdEndQuery(
     stream->write((uint32_t*)&local_query, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdEndQuery readParams");
     AEMU_SCOPED_TRACE("vkCmdEndQuery returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdEndQuery");;
 }
 
@@ -9495,7 +9727,7 @@ void VkEncoder::vkCmdResetQueryPool(
     uint32_t firstQuery,
     uint32_t queryCount)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdResetQueryPool encode");
     mImpl->log("start vkCmdResetQueryPool");
     auto stream = mImpl->stream();
@@ -9537,6 +9769,9 @@ void VkEncoder::vkCmdResetQueryPool(
     stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdResetQueryPool readParams");
     AEMU_SCOPED_TRACE("vkCmdResetQueryPool returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdResetQueryPool");;
 }
 
@@ -9546,7 +9781,7 @@ void VkEncoder::vkCmdWriteTimestamp(
     VkQueryPool queryPool,
     uint32_t query)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdWriteTimestamp encode");
     mImpl->log("start vkCmdWriteTimestamp");
     auto stream = mImpl->stream();
@@ -9588,6 +9823,9 @@ void VkEncoder::vkCmdWriteTimestamp(
     stream->write((uint32_t*)&local_query, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdWriteTimestamp readParams");
     AEMU_SCOPED_TRACE("vkCmdWriteTimestamp returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdWriteTimestamp");;
 }
 
@@ -9601,7 +9839,7 @@ void VkEncoder::vkCmdCopyQueryPoolResults(
     VkDeviceSize stride,
     VkQueryResultFlags flags)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults encode");
     mImpl->log("start vkCmdCopyQueryPoolResults");
     auto stream = mImpl->stream();
@@ -9663,6 +9901,9 @@ void VkEncoder::vkCmdCopyQueryPoolResults(
     stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
     AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults readParams");
     AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdCopyQueryPoolResults");;
 }
 
@@ -9674,7 +9915,7 @@ void VkEncoder::vkCmdPushConstants(
     uint32_t size,
     const void* pValues)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdPushConstants encode");
     mImpl->log("start vkCmdPushConstants");
     auto stream = mImpl->stream();
@@ -9728,6 +9969,9 @@ void VkEncoder::vkCmdPushConstants(
     stream->write((void*)local_pValues, ((size)) * sizeof(uint8_t));
     AEMU_SCOPED_TRACE("vkCmdPushConstants readParams");
     AEMU_SCOPED_TRACE("vkCmdPushConstants returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdPushConstants");;
 }
 
@@ -9736,7 +9980,7 @@ void VkEncoder::vkCmdBeginRenderPass(
     const VkRenderPassBeginInfo* pRenderPassBegin,
     VkSubpassContents contents)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdBeginRenderPass encode");
     mImpl->log("start vkCmdBeginRenderPass");
     auto stream = mImpl->stream();
@@ -9779,6 +10023,9 @@ void VkEncoder::vkCmdBeginRenderPass(
     stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
     AEMU_SCOPED_TRACE("vkCmdBeginRenderPass readParams");
     AEMU_SCOPED_TRACE("vkCmdBeginRenderPass returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdBeginRenderPass");;
 }
 
@@ -9786,7 +10033,7 @@ void VkEncoder::vkCmdNextSubpass(
     VkCommandBuffer commandBuffer,
     VkSubpassContents contents)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdNextSubpass encode");
     mImpl->log("start vkCmdNextSubpass");
     auto stream = mImpl->stream();
@@ -9816,13 +10063,16 @@ void VkEncoder::vkCmdNextSubpass(
     stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
     AEMU_SCOPED_TRACE("vkCmdNextSubpass readParams");
     AEMU_SCOPED_TRACE("vkCmdNextSubpass returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdNextSubpass");;
 }
 
 void VkEncoder::vkCmdEndRenderPass(
     VkCommandBuffer commandBuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdEndRenderPass encode");
     mImpl->log("start vkCmdEndRenderPass");
     auto stream = mImpl->stream();
@@ -9848,6 +10098,9 @@ void VkEncoder::vkCmdEndRenderPass(
     stream->write((uint64_t*)&cgen_var_658, 1 * 8);
     AEMU_SCOPED_TRACE("vkCmdEndRenderPass readParams");
     AEMU_SCOPED_TRACE("vkCmdEndRenderPass returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdEndRenderPass");;
 }
 
@@ -9856,7 +10109,7 @@ void VkEncoder::vkCmdExecuteCommands(
     uint32_t commandBufferCount,
     const VkCommandBuffer* pCommandBuffers)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdExecuteCommands encode");
     mImpl->log("start vkCmdExecuteCommands");
     auto stream = mImpl->stream();
@@ -9906,6 +10159,9 @@ void VkEncoder::vkCmdExecuteCommands(
     }
     AEMU_SCOPED_TRACE("vkCmdExecuteCommands readParams");
     AEMU_SCOPED_TRACE("vkCmdExecuteCommands returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdExecuteCommands");;
 }
 
@@ -9914,7 +10170,7 @@ void VkEncoder::vkCmdExecuteCommands(
 VkResult VkEncoder::vkEnumerateInstanceVersion(
     uint32_t* pApiVersion)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion encode");
     mImpl->log("start vkEnumerateInstanceVersion");
     auto stream = mImpl->stream();
@@ -9937,9 +10193,9 @@ VkResult VkEncoder::vkEnumerateInstanceVersion(
     AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion returnUnmarshal");
     VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
     stream->read(&vkEnumerateInstanceVersion_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkEnumerateInstanceVersion");;
     return vkEnumerateInstanceVersion_VkResult_return;
 }
@@ -9949,7 +10205,7 @@ VkResult VkEncoder::vkBindBufferMemory2(
     uint32_t bindInfoCount,
     const VkBindBufferMemoryInfo* pBindInfos)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkBindBufferMemory2 encode");
     mImpl->log("start vkBindBufferMemory2");
     auto stream = mImpl->stream();
@@ -10006,9 +10262,9 @@ VkResult VkEncoder::vkBindBufferMemory2(
     AEMU_SCOPED_TRACE("vkBindBufferMemory2 returnUnmarshal");
     VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
     stream->read(&vkBindBufferMemory2_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkBindBufferMemory2");;
     return vkBindBufferMemory2_VkResult_return;
 }
@@ -10018,7 +10274,7 @@ VkResult VkEncoder::vkBindImageMemory2(
     uint32_t bindInfoCount,
     const VkBindImageMemoryInfo* pBindInfos)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkBindImageMemory2 encode");
     mImpl->log("start vkBindImageMemory2");
     auto stream = mImpl->stream();
@@ -10075,9 +10331,9 @@ VkResult VkEncoder::vkBindImageMemory2(
     AEMU_SCOPED_TRACE("vkBindImageMemory2 returnUnmarshal");
     VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
     stream->read(&vkBindImageMemory2_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkBindImageMemory2");;
     return vkBindImageMemory2_VkResult_return;
 }
@@ -10089,7 +10345,7 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeatures(
     uint32_t remoteDeviceIndex,
     VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures encode");
     mImpl->log("start vkGetDeviceGroupPeerMemoryFeatures");
     auto stream = mImpl->stream();
@@ -10130,6 +10386,9 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeatures(
     AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures readParams");
     stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
     AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetDeviceGroupPeerMemoryFeatures");;
 }
 
@@ -10137,7 +10396,7 @@ void VkEncoder::vkCmdSetDeviceMask(
     VkCommandBuffer commandBuffer,
     uint32_t deviceMask)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetDeviceMask encode");
     mImpl->log("start vkCmdSetDeviceMask");
     auto stream = mImpl->stream();
@@ -10167,6 +10426,9 @@ void VkEncoder::vkCmdSetDeviceMask(
     stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdSetDeviceMask readParams");
     AEMU_SCOPED_TRACE("vkCmdSetDeviceMask returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetDeviceMask");;
 }
 
@@ -10179,7 +10441,7 @@ void VkEncoder::vkCmdDispatchBase(
     uint32_t groupCountY,
     uint32_t groupCountZ)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDispatchBase encode");
     mImpl->log("start vkCmdDispatchBase");
     auto stream = mImpl->stream();
@@ -10229,6 +10491,9 @@ void VkEncoder::vkCmdDispatchBase(
     stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDispatchBase readParams");
     AEMU_SCOPED_TRACE("vkCmdDispatchBase returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDispatchBase");;
 }
 
@@ -10237,7 +10502,7 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups(
     uint32_t* pPhysicalDeviceGroupCount,
     VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups encode");
     mImpl->log("start vkEnumeratePhysicalDeviceGroups");
     auto stream = mImpl->stream();
@@ -10331,9 +10596,9 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups(
     AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups returnUnmarshal");
     VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
     stream->read(&vkEnumeratePhysicalDeviceGroups_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkEnumeratePhysicalDeviceGroups");;
     return vkEnumeratePhysicalDeviceGroups_VkResult_return;
 }
@@ -10343,7 +10608,7 @@ void VkEncoder::vkGetImageMemoryRequirements2(
     const VkImageMemoryRequirementsInfo2* pInfo,
     VkMemoryRequirements2* pMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2 encode");
     mImpl->log("start vkGetImageMemoryRequirements2");
     auto stream = mImpl->stream();
@@ -10389,6 +10654,9 @@ void VkEncoder::vkGetImageMemoryRequirements2(
         transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements));
     }
     AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2 returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetImageMemoryRequirements2");;
 }
 
@@ -10397,7 +10665,7 @@ void VkEncoder::vkGetBufferMemoryRequirements2(
     const VkBufferMemoryRequirementsInfo2* pInfo,
     VkMemoryRequirements2* pMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2 encode");
     mImpl->log("start vkGetBufferMemoryRequirements2");
     auto stream = mImpl->stream();
@@ -10443,6 +10711,9 @@ void VkEncoder::vkGetBufferMemoryRequirements2(
         transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements));
     }
     AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2 returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetBufferMemoryRequirements2");;
 }
 
@@ -10452,7 +10723,7 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2(
     uint32_t* pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2 encode");
     mImpl->log("start vkGetImageSparseMemoryRequirements2");
     auto stream = mImpl->stream();
@@ -10557,6 +10828,9 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2(
         }
     }
     AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2 returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetImageSparseMemoryRequirements2");;
 }
 
@@ -10564,7 +10838,7 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceFeatures2* pFeatures)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2 encode");
     mImpl->log("start vkGetPhysicalDeviceFeatures2");
     auto stream = mImpl->stream();
@@ -10597,6 +10871,9 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2(
         transform_fromhost_VkPhysicalDeviceFeatures2(mImpl->resources(), (VkPhysicalDeviceFeatures2*)(pFeatures));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2 returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceFeatures2");;
 }
 
@@ -10604,7 +10881,7 @@ void VkEncoder::vkGetPhysicalDeviceProperties2(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceProperties2* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceProperties2");
     auto stream = mImpl->stream();
@@ -10637,9 +10914,10 @@ void VkEncoder::vkGetPhysicalDeviceProperties2(
         transform_fromhost_VkPhysicalDeviceProperties2(mImpl->resources(), (VkPhysicalDeviceProperties2*)(pProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2 returnUnmarshal");
-    encoderLock.unlock();
     mImpl->resources()->on_vkGetPhysicalDeviceProperties2(this, physicalDevice, pProperties);
-    encoderLock.lock();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceProperties2");;
 }
 
@@ -10648,7 +10926,7 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2(
     VkFormat format,
     VkFormatProperties2* pFormatProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceFormatProperties2");
     auto stream = mImpl->stream();
@@ -10685,6 +10963,9 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2(
         transform_fromhost_VkFormatProperties2(mImpl->resources(), (VkFormatProperties2*)(pFormatProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2 returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceFormatProperties2");;
 }
 
@@ -10693,7 +10974,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2(
     const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
     VkImageFormatProperties2* pImageFormatProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceImageFormatProperties2");
     auto stream = mImpl->stream();
@@ -10741,9 +11022,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2 returnUnmarshal");
     VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceImageFormatProperties2_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceImageFormatProperties2");;
     return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
 }
@@ -10753,7 +11034,7 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2(
     uint32_t* pQueueFamilyPropertyCount,
     VkQueueFamilyProperties2* pQueueFamilyProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties2");
     auto stream = mImpl->stream();
@@ -10845,6 +11126,9 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2(
         }
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2 returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceQueueFamilyProperties2");;
 }
 
@@ -10852,7 +11136,7 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceMemoryProperties2");
     auto stream = mImpl->stream();
@@ -10885,9 +11169,10 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2(
         transform_fromhost_VkPhysicalDeviceMemoryProperties2(mImpl->resources(), (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 returnUnmarshal");
-    encoderLock.unlock();
     mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties2(this, physicalDevice, pMemoryProperties);
-    encoderLock.lock();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceMemoryProperties2");;
 }
 
@@ -10897,7 +11182,7 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2(
     uint32_t* pPropertyCount,
     VkSparseImageFormatProperties2* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties2");
     auto stream = mImpl->stream();
@@ -11002,6 +11287,9 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2(
         }
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2 returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceSparseImageFormatProperties2");;
 }
 
@@ -11010,7 +11298,7 @@ void VkEncoder::vkTrimCommandPool(
     VkCommandPool commandPool,
     VkCommandPoolTrimFlags flags)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkTrimCommandPool encode");
     mImpl->log("start vkTrimCommandPool");
     auto stream = mImpl->stream();
@@ -11048,6 +11336,9 @@ void VkEncoder::vkTrimCommandPool(
     stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
     AEMU_SCOPED_TRACE("vkTrimCommandPool readParams");
     AEMU_SCOPED_TRACE("vkTrimCommandPool returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkTrimCommandPool");;
 }
 
@@ -11056,7 +11347,7 @@ void VkEncoder::vkGetDeviceQueue2(
     const VkDeviceQueueInfo2* pQueueInfo,
     VkQueue* pQueue)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDeviceQueue2 encode");
     mImpl->log("start vkGetDeviceQueue2");
     auto stream = mImpl->stream();
@@ -11106,6 +11397,9 @@ void VkEncoder::vkGetDeviceQueue2(
     stream->read((uint64_t*)&cgen_var_727, 8);
     stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_727, (VkQueue*)pQueue, 1);
     AEMU_SCOPED_TRACE("vkGetDeviceQueue2 returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetDeviceQueue2");;
 }
 
@@ -11115,7 +11409,7 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversion(
     const VkAllocationCallbacks* pAllocator,
     VkSamplerYcbcrConversion* pYcbcrConversion)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion encode");
     mImpl->log("start vkCreateSamplerYcbcrConversion");
     auto stream = mImpl->stream();
@@ -11195,9 +11489,9 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversion(
     AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion returnUnmarshal");
     VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSamplerYcbcrConversion_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateSamplerYcbcrConversion");;
     return vkCreateSamplerYcbcrConversion_VkResult_return;
 }
@@ -11207,7 +11501,7 @@ void VkEncoder::vkDestroySamplerYcbcrConversion(
     VkSamplerYcbcrConversion ycbcrConversion,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion encode");
     mImpl->log("start vkDestroySamplerYcbcrConversion");
     auto stream = mImpl->stream();
@@ -11268,6 +11562,9 @@ void VkEncoder::vkDestroySamplerYcbcrConversion(
     AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion readParams");
     AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroySamplerYcbcrConversion");;
 }
 
@@ -11277,7 +11574,7 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplate(
     const VkAllocationCallbacks* pAllocator,
     VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate encode");
     mImpl->log("start vkCreateDescriptorUpdateTemplate");
     auto stream = mImpl->stream();
@@ -11357,12 +11654,10 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplate(
     AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate returnUnmarshal");
     VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorUpdateTemplate_VkResult_return, sizeof(VkResult));
+    mImpl->resources()->on_vkCreateDescriptorUpdateTemplate(this, vkCreateDescriptorUpdateTemplate_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
-    encoderLock.unlock();
-    mImpl->resources()->on_vkCreateDescriptorUpdateTemplate(this, vkCreateDescriptorUpdateTemplate_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-    encoderLock.lock();
     mImpl->log("finish vkCreateDescriptorUpdateTemplate");;
     return vkCreateDescriptorUpdateTemplate_VkResult_return;
 }
@@ -11372,7 +11667,7 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplate(
     VkDescriptorUpdateTemplate descriptorUpdateTemplate,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate encode");
     mImpl->log("start vkDestroyDescriptorUpdateTemplate");
     auto stream = mImpl->stream();
@@ -11433,6 +11728,9 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplate(
     AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate readParams");
     AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyDescriptorUpdateTemplate");;
 }
 
@@ -11442,7 +11740,7 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplate(
     VkDescriptorUpdateTemplate descriptorUpdateTemplate,
     const void* pData)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate encode");
     mImpl->log("start vkUpdateDescriptorSetWithTemplate");
     auto stream = mImpl->stream();
@@ -11504,6 +11802,9 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplate(
     }
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate readParams");
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkUpdateDescriptorSetWithTemplate");;
 }
 
@@ -11512,7 +11813,7 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferProperties(
     const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
     VkExternalBufferProperties* pExternalBufferProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties encode");
     mImpl->log("start vkGetPhysicalDeviceExternalBufferProperties");
     auto stream = mImpl->stream();
@@ -11560,6 +11861,9 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferProperties(
         transform_fromhost_VkExternalBufferProperties(mImpl->resources(), (VkExternalBufferProperties*)(pExternalBufferProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceExternalBufferProperties");;
 }
 
@@ -11568,7 +11872,7 @@ void VkEncoder::vkGetPhysicalDeviceExternalFenceProperties(
     const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
     VkExternalFenceProperties* pExternalFenceProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties encode");
     mImpl->log("start vkGetPhysicalDeviceExternalFenceProperties");
     auto stream = mImpl->stream();
@@ -11614,6 +11918,9 @@ void VkEncoder::vkGetPhysicalDeviceExternalFenceProperties(
         transform_fromhost_VkExternalFenceProperties(mImpl->resources(), (VkExternalFenceProperties*)(pExternalFenceProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceExternalFenceProperties");;
 }
 
@@ -11622,7 +11929,7 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphoreProperties(
     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
     VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties encode");
     mImpl->log("start vkGetPhysicalDeviceExternalSemaphoreProperties");
     auto stream = mImpl->stream();
@@ -11668,6 +11975,9 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphoreProperties(
         transform_fromhost_VkExternalSemaphoreProperties(mImpl->resources(), (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceExternalSemaphoreProperties");;
 }
 
@@ -11676,7 +11986,7 @@ void VkEncoder::vkGetDescriptorSetLayoutSupport(
     const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
     VkDescriptorSetLayoutSupport* pSupport)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport encode");
     mImpl->log("start vkGetDescriptorSetLayoutSupport");
     auto stream = mImpl->stream();
@@ -11722,6 +12032,9 @@ void VkEncoder::vkGetDescriptorSetLayoutSupport(
         transform_fromhost_VkDescriptorSetLayoutSupport(mImpl->resources(), (VkDescriptorSetLayoutSupport*)(pSupport));
     }
     AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetDescriptorSetLayoutSupport");;
 }
 
@@ -11732,7 +12045,7 @@ void VkEncoder::vkDestroySurfaceKHR(
     VkSurfaceKHR surface,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroySurfaceKHR encode");
     mImpl->log("start vkDestroySurfaceKHR");
     auto stream = mImpl->stream();
@@ -11793,6 +12106,9 @@ void VkEncoder::vkDestroySurfaceKHR(
     AEMU_SCOPED_TRACE("vkDestroySurfaceKHR readParams");
     AEMU_SCOPED_TRACE("vkDestroySurfaceKHR returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&surface);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroySurfaceKHR");;
 }
 
@@ -11802,7 +12118,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceSupportKHR(
     VkSurfaceKHR surface,
     VkBool32* pSupported)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceSupportKHR");
     auto stream = mImpl->stream();
@@ -11845,9 +12161,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceSupportKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceSurfaceSupportKHR");;
     return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
 }
@@ -11857,7 +12173,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
     VkSurfaceKHR surface,
     VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
     auto stream = mImpl->stream();
@@ -11900,9 +12216,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceSurfaceCapabilitiesKHR");;
     return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
 }
@@ -11913,7 +12229,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR(
     uint32_t* pSurfaceFormatCount,
     VkSurfaceFormatKHR* pSurfaceFormats)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceFormatsKHR");
     auto stream = mImpl->stream();
@@ -12015,9 +12331,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceSurfaceFormatsKHR");;
     return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
 }
@@ -12028,7 +12344,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR(
     uint32_t* pPresentModeCount,
     VkPresentModeKHR* pPresentModes)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfacePresentModesKHR");
     auto stream = mImpl->stream();
@@ -12114,9 +12430,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceSurfacePresentModesKHR");;
     return vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
 }
@@ -12129,7 +12445,7 @@ VkResult VkEncoder::vkCreateSwapchainKHR(
     const VkAllocationCallbacks* pAllocator,
     VkSwapchainKHR* pSwapchain)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateSwapchainKHR encode");
     mImpl->log("start vkCreateSwapchainKHR");
     auto stream = mImpl->stream();
@@ -12209,9 +12525,9 @@ VkResult VkEncoder::vkCreateSwapchainKHR(
     AEMU_SCOPED_TRACE("vkCreateSwapchainKHR returnUnmarshal");
     VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSwapchainKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateSwapchainKHR");;
     return vkCreateSwapchainKHR_VkResult_return;
 }
@@ -12221,7 +12537,7 @@ void VkEncoder::vkDestroySwapchainKHR(
     VkSwapchainKHR swapchain,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroySwapchainKHR encode");
     mImpl->log("start vkDestroySwapchainKHR");
     auto stream = mImpl->stream();
@@ -12282,6 +12598,9 @@ void VkEncoder::vkDestroySwapchainKHR(
     AEMU_SCOPED_TRACE("vkDestroySwapchainKHR readParams");
     AEMU_SCOPED_TRACE("vkDestroySwapchainKHR returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&swapchain);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroySwapchainKHR");;
 }
 
@@ -12291,7 +12610,7 @@ VkResult VkEncoder::vkGetSwapchainImagesKHR(
     uint32_t* pSwapchainImageCount,
     VkImage* pSwapchainImages)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR encode");
     mImpl->log("start vkGetSwapchainImagesKHR");
     auto stream = mImpl->stream();
@@ -12397,9 +12716,9 @@ VkResult VkEncoder::vkGetSwapchainImagesKHR(
     AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR returnUnmarshal");
     VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetSwapchainImagesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetSwapchainImagesKHR");;
     return vkGetSwapchainImagesKHR_VkResult_return;
 }
@@ -12412,7 +12731,7 @@ VkResult VkEncoder::vkAcquireNextImageKHR(
     VkFence fence,
     uint32_t* pImageIndex)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkAcquireNextImageKHR encode");
     mImpl->log("start vkAcquireNextImageKHR");
     auto stream = mImpl->stream();
@@ -12471,9 +12790,9 @@ VkResult VkEncoder::vkAcquireNextImageKHR(
     AEMU_SCOPED_TRACE("vkAcquireNextImageKHR returnUnmarshal");
     VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
     stream->read(&vkAcquireNextImageKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkAcquireNextImageKHR");;
     return vkAcquireNextImageKHR_VkResult_return;
 }
@@ -12482,7 +12801,7 @@ VkResult VkEncoder::vkQueuePresentKHR(
     VkQueue queue,
     const VkPresentInfoKHR* pPresentInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkQueuePresentKHR encode");
     mImpl->log("start vkQueuePresentKHR");
     auto stream = mImpl->stream();
@@ -12523,9 +12842,9 @@ VkResult VkEncoder::vkQueuePresentKHR(
     AEMU_SCOPED_TRACE("vkQueuePresentKHR returnUnmarshal");
     VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
     stream->read(&vkQueuePresentKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkQueuePresentKHR");;
     return vkQueuePresentKHR_VkResult_return;
 }
@@ -12534,7 +12853,7 @@ VkResult VkEncoder::vkGetDeviceGroupPresentCapabilitiesKHR(
     VkDevice device,
     VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR encode");
     mImpl->log("start vkGetDeviceGroupPresentCapabilitiesKHR");
     auto stream = mImpl->stream();
@@ -12569,9 +12888,9 @@ VkResult VkEncoder::vkGetDeviceGroupPresentCapabilitiesKHR(
     AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR returnUnmarshal");
     VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetDeviceGroupPresentCapabilitiesKHR");;
     return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
 }
@@ -12581,7 +12900,7 @@ VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR(
     VkSurfaceKHR surface,
     VkDeviceGroupPresentModeFlagsKHR* pModes)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR encode");
     mImpl->log("start vkGetDeviceGroupSurfacePresentModesKHR");
     auto stream = mImpl->stream();
@@ -12642,9 +12961,9 @@ VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR(
     AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR returnUnmarshal");
     VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetDeviceGroupSurfacePresentModesKHR");;
     return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
 }
@@ -12655,7 +12974,7 @@ VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR(
     uint32_t* pRectCount,
     VkRect2D* pRects)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR encode");
     mImpl->log("start vkGetPhysicalDevicePresentRectanglesKHR");
     auto stream = mImpl->stream();
@@ -12757,9 +13076,9 @@ VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR returnUnmarshal");
     VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDevicePresentRectanglesKHR");;
     return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
 }
@@ -12769,7 +13088,7 @@ VkResult VkEncoder::vkAcquireNextImage2KHR(
     const VkAcquireNextImageInfoKHR* pAcquireInfo,
     uint32_t* pImageIndex)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR encode");
     mImpl->log("start vkAcquireNextImage2KHR");
     auto stream = mImpl->stream();
@@ -12813,9 +13132,9 @@ VkResult VkEncoder::vkAcquireNextImage2KHR(
     AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR returnUnmarshal");
     VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkAcquireNextImage2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkAcquireNextImage2KHR");;
     return vkAcquireNextImage2KHR_VkResult_return;
 }
@@ -12827,7 +13146,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR(
     uint32_t* pPropertyCount,
     VkDisplayPropertiesKHR* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceDisplayPropertiesKHR");
     auto stream = mImpl->stream();
@@ -12921,9 +13240,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceDisplayPropertiesKHR");;
     return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
 }
@@ -12933,7 +13252,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
     uint32_t* pPropertyCount,
     VkDisplayPlanePropertiesKHR* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
     auto stream = mImpl->stream();
@@ -13027,9 +13346,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceDisplayPlanePropertiesKHR");;
     return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
 }
@@ -13040,7 +13359,7 @@ VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR(
     uint32_t* pDisplayCount,
     VkDisplayKHR* pDisplays)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR encode");
     mImpl->log("start vkGetDisplayPlaneSupportedDisplaysKHR");
     auto stream = mImpl->stream();
@@ -13142,9 +13461,9 @@ VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR(
     AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR returnUnmarshal");
     VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetDisplayPlaneSupportedDisplaysKHR");;
     return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
 }
@@ -13155,7 +13474,7 @@ VkResult VkEncoder::vkGetDisplayModePropertiesKHR(
     uint32_t* pPropertyCount,
     VkDisplayModePropertiesKHR* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR encode");
     mImpl->log("start vkGetDisplayModePropertiesKHR");
     auto stream = mImpl->stream();
@@ -13257,9 +13576,9 @@ VkResult VkEncoder::vkGetDisplayModePropertiesKHR(
     AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR returnUnmarshal");
     VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDisplayModePropertiesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetDisplayModePropertiesKHR");;
     return vkGetDisplayModePropertiesKHR_VkResult_return;
 }
@@ -13271,7 +13590,7 @@ VkResult VkEncoder::vkCreateDisplayModeKHR(
     const VkAllocationCallbacks* pAllocator,
     VkDisplayModeKHR* pMode)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR encode");
     mImpl->log("start vkCreateDisplayModeKHR");
     auto stream = mImpl->stream();
@@ -13359,9 +13678,9 @@ VkResult VkEncoder::vkCreateDisplayModeKHR(
     AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR returnUnmarshal");
     VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDisplayModeKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateDisplayModeKHR");;
     return vkCreateDisplayModeKHR_VkResult_return;
 }
@@ -13372,7 +13691,7 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilitiesKHR(
     uint32_t planeIndex,
     VkDisplayPlaneCapabilitiesKHR* pCapabilities)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR encode");
     mImpl->log("start vkGetDisplayPlaneCapabilitiesKHR");
     auto stream = mImpl->stream();
@@ -13419,9 +13738,9 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilitiesKHR(
     AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR returnUnmarshal");
     VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDisplayPlaneCapabilitiesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetDisplayPlaneCapabilitiesKHR");;
     return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
 }
@@ -13432,7 +13751,7 @@ VkResult VkEncoder::vkCreateDisplayPlaneSurfaceKHR(
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR encode");
     mImpl->log("start vkCreateDisplayPlaneSurfaceKHR");
     auto stream = mImpl->stream();
@@ -13510,9 +13829,9 @@ VkResult VkEncoder::vkCreateDisplayPlaneSurfaceKHR(
     AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR returnUnmarshal");
     VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDisplayPlaneSurfaceKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateDisplayPlaneSurfaceKHR");;
     return vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
 }
@@ -13526,7 +13845,7 @@ VkResult VkEncoder::vkCreateSharedSwapchainsKHR(
     const VkAllocationCallbacks* pAllocator,
     VkSwapchainKHR* pSwapchains)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR encode");
     mImpl->log("start vkCreateSharedSwapchainsKHR");
     auto stream = mImpl->stream();
@@ -13632,9 +13951,9 @@ VkResult VkEncoder::vkCreateSharedSwapchainsKHR(
     AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR returnUnmarshal");
     VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSharedSwapchainsKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateSharedSwapchainsKHR");;
     return vkCreateSharedSwapchainsKHR_VkResult_return;
 }
@@ -13647,7 +13966,7 @@ VkResult VkEncoder::vkCreateXlibSurfaceKHR(
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR encode");
     mImpl->log("start vkCreateXlibSurfaceKHR");
     auto stream = mImpl->stream();
@@ -13725,9 +14044,9 @@ VkResult VkEncoder::vkCreateXlibSurfaceKHR(
     AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR returnUnmarshal");
     VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateXlibSurfaceKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateXlibSurfaceKHR");;
     return vkCreateXlibSurfaceKHR_VkResult_return;
 }
@@ -13738,7 +14057,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXlibPresentationSupportKHR(
     Display* dpy,
     VisualID visualID)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceXlibPresentationSupportKHR");
     auto stream = mImpl->stream();
@@ -13777,9 +14096,9 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXlibPresentationSupportKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR returnUnmarshal");
     VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceXlibPresentationSupportKHR");;
     return vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
 }
@@ -13792,7 +14111,7 @@ VkResult VkEncoder::vkCreateXcbSurfaceKHR(
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR encode");
     mImpl->log("start vkCreateXcbSurfaceKHR");
     auto stream = mImpl->stream();
@@ -13870,9 +14189,9 @@ VkResult VkEncoder::vkCreateXcbSurfaceKHR(
     AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR returnUnmarshal");
     VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateXcbSurfaceKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateXcbSurfaceKHR");;
     return vkCreateXcbSurfaceKHR_VkResult_return;
 }
@@ -13883,7 +14202,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXcbPresentationSupportKHR(
     xcb_connection_t* connection,
     xcb_visualid_t visual_id)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceXcbPresentationSupportKHR");
     auto stream = mImpl->stream();
@@ -13922,9 +14241,9 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXcbPresentationSupportKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR returnUnmarshal");
     VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceXcbPresentationSupportKHR");;
     return vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
 }
@@ -13937,7 +14256,7 @@ VkResult VkEncoder::vkCreateWaylandSurfaceKHR(
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR encode");
     mImpl->log("start vkCreateWaylandSurfaceKHR");
     auto stream = mImpl->stream();
@@ -14015,9 +14334,9 @@ VkResult VkEncoder::vkCreateWaylandSurfaceKHR(
     AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR returnUnmarshal");
     VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateWaylandSurfaceKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateWaylandSurfaceKHR");;
     return vkCreateWaylandSurfaceKHR_VkResult_return;
 }
@@ -14027,7 +14346,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWaylandPresentationSupportKHR(
     uint32_t queueFamilyIndex,
     wl_display* display)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceWaylandPresentationSupportKHR");
     auto stream = mImpl->stream();
@@ -14062,9 +14381,9 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWaylandPresentationSupportKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR returnUnmarshal");
     VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceWaylandPresentationSupportKHR");;
     return vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
 }
@@ -14077,7 +14396,7 @@ VkResult VkEncoder::vkCreateMirSurfaceKHR(
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR encode");
     mImpl->log("start vkCreateMirSurfaceKHR");
     auto stream = mImpl->stream();
@@ -14155,9 +14474,9 @@ VkResult VkEncoder::vkCreateMirSurfaceKHR(
     AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR returnUnmarshal");
     VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateMirSurfaceKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateMirSurfaceKHR");;
     return vkCreateMirSurfaceKHR_VkResult_return;
 }
@@ -14167,7 +14486,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceMirPresentationSupportKHR(
     uint32_t queueFamilyIndex,
     MirConnection* connection)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceMirPresentationSupportKHR");
     auto stream = mImpl->stream();
@@ -14202,9 +14521,9 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceMirPresentationSupportKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR returnUnmarshal");
     VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceMirPresentationSupportKHR");;
     return vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return;
 }
@@ -14217,7 +14536,7 @@ VkResult VkEncoder::vkCreateAndroidSurfaceKHR(
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR encode");
     mImpl->log("start vkCreateAndroidSurfaceKHR");
     auto stream = mImpl->stream();
@@ -14295,9 +14614,9 @@ VkResult VkEncoder::vkCreateAndroidSurfaceKHR(
     AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR returnUnmarshal");
     VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateAndroidSurfaceKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateAndroidSurfaceKHR");;
     return vkCreateAndroidSurfaceKHR_VkResult_return;
 }
@@ -14310,7 +14629,7 @@ VkResult VkEncoder::vkCreateWin32SurfaceKHR(
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR encode");
     mImpl->log("start vkCreateWin32SurfaceKHR");
     auto stream = mImpl->stream();
@@ -14388,9 +14707,9 @@ VkResult VkEncoder::vkCreateWin32SurfaceKHR(
     AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR returnUnmarshal");
     VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateWin32SurfaceKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateWin32SurfaceKHR");;
     return vkCreateWin32SurfaceKHR_VkResult_return;
 }
@@ -14399,7 +14718,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWin32PresentationSupportKHR(
     VkPhysicalDevice physicalDevice,
     uint32_t queueFamilyIndex)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceWin32PresentationSupportKHR");
     auto stream = mImpl->stream();
@@ -14431,9 +14750,9 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWin32PresentationSupportKHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR returnUnmarshal");
     VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceWin32PresentationSupportKHR");;
     return vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
 }
@@ -14448,7 +14767,7 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2KHR(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceFeatures2* pFeatures)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceFeatures2KHR");
     auto stream = mImpl->stream();
@@ -14481,6 +14800,9 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2KHR(
         transform_fromhost_VkPhysicalDeviceFeatures2(mImpl->resources(), (VkPhysicalDeviceFeatures2*)(pFeatures));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceFeatures2KHR");;
 }
 
@@ -14488,7 +14810,7 @@ void VkEncoder::vkGetPhysicalDeviceProperties2KHR(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceProperties2* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceProperties2KHR");
     auto stream = mImpl->stream();
@@ -14521,9 +14843,10 @@ void VkEncoder::vkGetPhysicalDeviceProperties2KHR(
         transform_fromhost_VkPhysicalDeviceProperties2(mImpl->resources(), (VkPhysicalDeviceProperties2*)(pProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR returnUnmarshal");
-    encoderLock.unlock();
     mImpl->resources()->on_vkGetPhysicalDeviceProperties2KHR(this, physicalDevice, pProperties);
-    encoderLock.lock();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceProperties2KHR");;
 }
 
@@ -14532,7 +14855,7 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2KHR(
     VkFormat format,
     VkFormatProperties2* pFormatProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceFormatProperties2KHR");
     auto stream = mImpl->stream();
@@ -14569,6 +14892,9 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2KHR(
         transform_fromhost_VkFormatProperties2(mImpl->resources(), (VkFormatProperties2*)(pFormatProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceFormatProperties2KHR");;
 }
 
@@ -14577,7 +14903,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2KHR(
     const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
     VkImageFormatProperties2* pImageFormatProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceImageFormatProperties2KHR");
     auto stream = mImpl->stream();
@@ -14625,9 +14951,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2KHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceImageFormatProperties2KHR");;
     return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
 }
@@ -14637,7 +14963,7 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
     uint32_t* pQueueFamilyPropertyCount,
     VkQueueFamilyProperties2* pQueueFamilyProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties2KHR");
     auto stream = mImpl->stream();
@@ -14729,6 +15055,9 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
         }
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceQueueFamilyProperties2KHR");;
 }
 
@@ -14736,7 +15065,7 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2KHR(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceMemoryProperties2KHR");
     auto stream = mImpl->stream();
@@ -14769,9 +15098,10 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2KHR(
         transform_fromhost_VkPhysicalDeviceMemoryProperties2(mImpl->resources(), (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR returnUnmarshal");
-    encoderLock.unlock();
     mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties2KHR(this, physicalDevice, pMemoryProperties);
-    encoderLock.lock();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceMemoryProperties2KHR");;
 }
 
@@ -14781,7 +15111,7 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
     uint32_t* pPropertyCount,
     VkSparseImageFormatProperties2* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
     auto stream = mImpl->stream();
@@ -14886,6 +15216,9 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
         }
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceSparseImageFormatProperties2KHR");;
 }
 
@@ -14898,7 +15231,7 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeaturesKHR(
     uint32_t remoteDeviceIndex,
     VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR encode");
     mImpl->log("start vkGetDeviceGroupPeerMemoryFeaturesKHR");
     auto stream = mImpl->stream();
@@ -14939,6 +15272,9 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeaturesKHR(
     AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR readParams");
     stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
     AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetDeviceGroupPeerMemoryFeaturesKHR");;
 }
 
@@ -14946,7 +15282,7 @@ void VkEncoder::vkCmdSetDeviceMaskKHR(
     VkCommandBuffer commandBuffer,
     uint32_t deviceMask)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR encode");
     mImpl->log("start vkCmdSetDeviceMaskKHR");
     auto stream = mImpl->stream();
@@ -14976,6 +15312,9 @@ void VkEncoder::vkCmdSetDeviceMaskKHR(
     stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR readParams");
     AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetDeviceMaskKHR");;
 }
 
@@ -14988,7 +15327,7 @@ void VkEncoder::vkCmdDispatchBaseKHR(
     uint32_t groupCountY,
     uint32_t groupCountZ)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR encode");
     mImpl->log("start vkCmdDispatchBaseKHR");
     auto stream = mImpl->stream();
@@ -15038,6 +15377,9 @@ void VkEncoder::vkCmdDispatchBaseKHR(
     stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR readParams");
     AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDispatchBaseKHR");;
 }
 
@@ -15050,7 +15392,7 @@ void VkEncoder::vkTrimCommandPoolKHR(
     VkCommandPool commandPool,
     VkCommandPoolTrimFlags flags)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR encode");
     mImpl->log("start vkTrimCommandPoolKHR");
     auto stream = mImpl->stream();
@@ -15088,6 +15430,9 @@ void VkEncoder::vkTrimCommandPoolKHR(
     stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
     AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR readParams");
     AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkTrimCommandPoolKHR");;
 }
 
@@ -15098,7 +15443,7 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR(
     uint32_t* pPhysicalDeviceGroupCount,
     VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR encode");
     mImpl->log("start vkEnumeratePhysicalDeviceGroupsKHR");
     auto stream = mImpl->stream();
@@ -15192,9 +15537,9 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR(
     AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR returnUnmarshal");
     VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
     stream->read(&vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkEnumeratePhysicalDeviceGroupsKHR");;
     return vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return;
 }
@@ -15206,7 +15551,7 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferPropertiesKHR(
     const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
     VkExternalBufferProperties* pExternalBufferProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceExternalBufferPropertiesKHR");
     auto stream = mImpl->stream();
@@ -15254,6 +15599,9 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferPropertiesKHR(
         transform_fromhost_VkExternalBufferProperties(mImpl->resources(), (VkExternalBufferProperties*)(pExternalBufferProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceExternalBufferPropertiesKHR");;
 }
 
@@ -15266,7 +15614,7 @@ VkResult VkEncoder::vkGetMemoryWin32HandleKHR(
     const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
     HANDLE* pHandle)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR encode");
     mImpl->log("start vkGetMemoryWin32HandleKHR");
     auto stream = mImpl->stream();
@@ -15310,9 +15658,9 @@ VkResult VkEncoder::vkGetMemoryWin32HandleKHR(
     AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR returnUnmarshal");
     VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryWin32HandleKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetMemoryWin32HandleKHR");;
     return vkGetMemoryWin32HandleKHR_VkResult_return;
 }
@@ -15323,7 +15671,7 @@ VkResult VkEncoder::vkGetMemoryWin32HandlePropertiesKHR(
     HANDLE handle,
     VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR encode");
     mImpl->log("start vkGetMemoryWin32HandlePropertiesKHR");
     auto stream = mImpl->stream();
@@ -15366,9 +15714,9 @@ VkResult VkEncoder::vkGetMemoryWin32HandlePropertiesKHR(
     AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR returnUnmarshal");
     VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryWin32HandlePropertiesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetMemoryWin32HandlePropertiesKHR");;
     return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
 }
@@ -15380,7 +15728,7 @@ VkResult VkEncoder::vkGetMemoryFdKHR(
     const VkMemoryGetFdInfoKHR* pGetFdInfo,
     int* pFd)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetMemoryFdKHR encode");
     mImpl->log("start vkGetMemoryFdKHR");
     auto stream = mImpl->stream();
@@ -15424,9 +15772,9 @@ VkResult VkEncoder::vkGetMemoryFdKHR(
     AEMU_SCOPED_TRACE("vkGetMemoryFdKHR returnUnmarshal");
     VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryFdKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetMemoryFdKHR");;
     return vkGetMemoryFdKHR_VkResult_return;
 }
@@ -15437,7 +15785,7 @@ VkResult VkEncoder::vkGetMemoryFdPropertiesKHR(
     int fd,
     VkMemoryFdPropertiesKHR* pMemoryFdProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR encode");
     mImpl->log("start vkGetMemoryFdPropertiesKHR");
     auto stream = mImpl->stream();
@@ -15480,9 +15828,9 @@ VkResult VkEncoder::vkGetMemoryFdPropertiesKHR(
     AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR returnUnmarshal");
     VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryFdPropertiesKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetMemoryFdPropertiesKHR");;
     return vkGetMemoryFdPropertiesKHR_VkResult_return;
 }
@@ -15496,7 +15844,7 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
     VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
     auto stream = mImpl->stream();
@@ -15542,6 +15890,9 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
         transform_fromhost_VkExternalSemaphoreProperties(mImpl->resources(), (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");;
 }
 
@@ -15553,7 +15904,7 @@ VkResult VkEncoder::vkImportSemaphoreWin32HandleKHR(
     VkDevice device,
     const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR encode");
     mImpl->log("start vkImportSemaphoreWin32HandleKHR");
     auto stream = mImpl->stream();
@@ -15594,9 +15945,9 @@ VkResult VkEncoder::vkImportSemaphoreWin32HandleKHR(
     AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR returnUnmarshal");
     VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkImportSemaphoreWin32HandleKHR");;
     return vkImportSemaphoreWin32HandleKHR_VkResult_return;
 }
@@ -15606,7 +15957,7 @@ VkResult VkEncoder::vkGetSemaphoreWin32HandleKHR(
     const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
     HANDLE* pHandle)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR encode");
     mImpl->log("start vkGetSemaphoreWin32HandleKHR");
     auto stream = mImpl->stream();
@@ -15650,9 +16001,9 @@ VkResult VkEncoder::vkGetSemaphoreWin32HandleKHR(
     AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR returnUnmarshal");
     VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetSemaphoreWin32HandleKHR");;
     return vkGetSemaphoreWin32HandleKHR_VkResult_return;
 }
@@ -15663,7 +16014,7 @@ VkResult VkEncoder::vkImportSemaphoreFdKHR(
     VkDevice device,
     const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR encode");
     mImpl->log("start vkImportSemaphoreFdKHR");
     auto stream = mImpl->stream();
@@ -15704,9 +16055,9 @@ VkResult VkEncoder::vkImportSemaphoreFdKHR(
     AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR returnUnmarshal");
     VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkImportSemaphoreFdKHR");;
     return vkImportSemaphoreFdKHR_VkResult_return;
 }
@@ -15716,7 +16067,7 @@ VkResult VkEncoder::vkGetSemaphoreFdKHR(
     const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
     int* pFd)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR encode");
     mImpl->log("start vkGetSemaphoreFdKHR");
     auto stream = mImpl->stream();
@@ -15760,9 +16111,9 @@ VkResult VkEncoder::vkGetSemaphoreFdKHR(
     AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR returnUnmarshal");
     VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetSemaphoreFdKHR");;
     return vkGetSemaphoreFdKHR_VkResult_return;
 }
@@ -15777,7 +16128,7 @@ void VkEncoder::vkCmdPushDescriptorSetKHR(
     uint32_t descriptorWriteCount,
     const VkWriteDescriptorSet* pDescriptorWrites)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR encode");
     mImpl->log("start vkCmdPushDescriptorSetKHR");
     auto stream = mImpl->stream();
@@ -15848,6 +16199,9 @@ void VkEncoder::vkCmdPushDescriptorSetKHR(
     }
     AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR readParams");
     AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdPushDescriptorSetKHR");;
 }
 
@@ -15858,7 +16212,7 @@ void VkEncoder::vkCmdPushDescriptorSetWithTemplateKHR(
     uint32_t set,
     const void* pData)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR encode");
     mImpl->log("start vkCmdPushDescriptorSetWithTemplateKHR");
     auto stream = mImpl->stream();
@@ -15924,6 +16278,9 @@ void VkEncoder::vkCmdPushDescriptorSetWithTemplateKHR(
     }
     AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR readParams");
     AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdPushDescriptorSetWithTemplateKHR");;
 }
 
@@ -15939,7 +16296,7 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplateKHR(
     const VkAllocationCallbacks* pAllocator,
     VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR encode");
     mImpl->log("start vkCreateDescriptorUpdateTemplateKHR");
     auto stream = mImpl->stream();
@@ -16019,12 +16376,10 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplateKHR(
     AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR returnUnmarshal");
     VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorUpdateTemplateKHR_VkResult_return, sizeof(VkResult));
+    mImpl->resources()->on_vkCreateDescriptorUpdateTemplateKHR(this, vkCreateDescriptorUpdateTemplateKHR_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
-    encoderLock.unlock();
-    mImpl->resources()->on_vkCreateDescriptorUpdateTemplateKHR(this, vkCreateDescriptorUpdateTemplateKHR_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-    encoderLock.lock();
     mImpl->log("finish vkCreateDescriptorUpdateTemplateKHR");;
     return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
 }
@@ -16034,7 +16389,7 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplateKHR(
     VkDescriptorUpdateTemplate descriptorUpdateTemplate,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR encode");
     mImpl->log("start vkDestroyDescriptorUpdateTemplateKHR");
     auto stream = mImpl->stream();
@@ -16095,6 +16450,9 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplateKHR(
     AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR readParams");
     AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyDescriptorUpdateTemplateKHR");;
 }
 
@@ -16104,7 +16462,7 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateKHR(
     VkDescriptorUpdateTemplate descriptorUpdateTemplate,
     const void* pData)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR encode");
     mImpl->log("start vkUpdateDescriptorSetWithTemplateKHR");
     auto stream = mImpl->stream();
@@ -16166,6 +16524,9 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateKHR(
     }
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR readParams");
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkUpdateDescriptorSetWithTemplateKHR");;
 }
 
@@ -16177,7 +16538,7 @@ VkResult VkEncoder::vkCreateRenderPass2KHR(
     const VkAllocationCallbacks* pAllocator,
     VkRenderPass* pRenderPass)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR encode");
     mImpl->log("start vkCreateRenderPass2KHR");
     auto stream = mImpl->stream();
@@ -16255,9 +16616,9 @@ VkResult VkEncoder::vkCreateRenderPass2KHR(
     AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR returnUnmarshal");
     VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateRenderPass2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateRenderPass2KHR");;
     return vkCreateRenderPass2KHR_VkResult_return;
 }
@@ -16267,7 +16628,7 @@ void VkEncoder::vkCmdBeginRenderPass2KHR(
     const VkRenderPassBeginInfo* pRenderPassBegin,
     const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR encode");
     mImpl->log("start vkCmdBeginRenderPass2KHR");
     auto stream = mImpl->stream();
@@ -16319,6 +16680,9 @@ void VkEncoder::vkCmdBeginRenderPass2KHR(
     marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
     AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR readParams");
     AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdBeginRenderPass2KHR");;
 }
 
@@ -16327,7 +16691,7 @@ void VkEncoder::vkCmdNextSubpass2KHR(
     const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
     const VkSubpassEndInfoKHR* pSubpassEndInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR encode");
     mImpl->log("start vkCmdNextSubpass2KHR");
     auto stream = mImpl->stream();
@@ -16379,6 +16743,9 @@ void VkEncoder::vkCmdNextSubpass2KHR(
     marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
     AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR readParams");
     AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdNextSubpass2KHR");;
 }
 
@@ -16386,7 +16753,7 @@ void VkEncoder::vkCmdEndRenderPass2KHR(
     VkCommandBuffer commandBuffer,
     const VkSubpassEndInfoKHR* pSubpassEndInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR encode");
     mImpl->log("start vkCmdEndRenderPass2KHR");
     auto stream = mImpl->stream();
@@ -16425,6 +16792,9 @@ void VkEncoder::vkCmdEndRenderPass2KHR(
     marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
     AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR readParams");
     AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdEndRenderPass2KHR");;
 }
 
@@ -16434,7 +16804,7 @@ VkResult VkEncoder::vkGetSwapchainStatusKHR(
     VkDevice device,
     VkSwapchainKHR swapchain)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR encode");
     mImpl->log("start vkGetSwapchainStatusKHR");
     auto stream = mImpl->stream();
@@ -16470,9 +16840,9 @@ VkResult VkEncoder::vkGetSwapchainStatusKHR(
     AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR returnUnmarshal");
     VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetSwapchainStatusKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetSwapchainStatusKHR");;
     return vkGetSwapchainStatusKHR_VkResult_return;
 }
@@ -16484,7 +16854,7 @@ void VkEncoder::vkGetPhysicalDeviceExternalFencePropertiesKHR(
     const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
     VkExternalFenceProperties* pExternalFenceProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceExternalFencePropertiesKHR");
     auto stream = mImpl->stream();
@@ -16530,6 +16900,9 @@ void VkEncoder::vkGetPhysicalDeviceExternalFencePropertiesKHR(
         transform_fromhost_VkExternalFenceProperties(mImpl->resources(), (VkExternalFenceProperties*)(pExternalFenceProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceExternalFencePropertiesKHR");;
 }
 
@@ -16541,7 +16914,7 @@ VkResult VkEncoder::vkImportFenceWin32HandleKHR(
     VkDevice device,
     const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR encode");
     mImpl->log("start vkImportFenceWin32HandleKHR");
     auto stream = mImpl->stream();
@@ -16582,9 +16955,9 @@ VkResult VkEncoder::vkImportFenceWin32HandleKHR(
     AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR returnUnmarshal");
     VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkImportFenceWin32HandleKHR");;
     return vkImportFenceWin32HandleKHR_VkResult_return;
 }
@@ -16594,7 +16967,7 @@ VkResult VkEncoder::vkGetFenceWin32HandleKHR(
     const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
     HANDLE* pHandle)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR encode");
     mImpl->log("start vkGetFenceWin32HandleKHR");
     auto stream = mImpl->stream();
@@ -16638,9 +17011,9 @@ VkResult VkEncoder::vkGetFenceWin32HandleKHR(
     AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR returnUnmarshal");
     VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetFenceWin32HandleKHR");;
     return vkGetFenceWin32HandleKHR_VkResult_return;
 }
@@ -16651,7 +17024,7 @@ VkResult VkEncoder::vkImportFenceFdKHR(
     VkDevice device,
     const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkImportFenceFdKHR encode");
     mImpl->log("start vkImportFenceFdKHR");
     auto stream = mImpl->stream();
@@ -16692,9 +17065,9 @@ VkResult VkEncoder::vkImportFenceFdKHR(
     AEMU_SCOPED_TRACE("vkImportFenceFdKHR returnUnmarshal");
     VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportFenceFdKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkImportFenceFdKHR");;
     return vkImportFenceFdKHR_VkResult_return;
 }
@@ -16704,7 +17077,7 @@ VkResult VkEncoder::vkGetFenceFdKHR(
     const VkFenceGetFdInfoKHR* pGetFdInfo,
     int* pFd)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetFenceFdKHR encode");
     mImpl->log("start vkGetFenceFdKHR");
     auto stream = mImpl->stream();
@@ -16748,9 +17121,9 @@ VkResult VkEncoder::vkGetFenceFdKHR(
     AEMU_SCOPED_TRACE("vkGetFenceFdKHR returnUnmarshal");
     VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetFenceFdKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetFenceFdKHR");;
     return vkGetFenceFdKHR_VkResult_return;
 }
@@ -16764,7 +17137,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2KHR(
     const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
     VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilities2KHR");
     auto stream = mImpl->stream();
@@ -16812,9 +17185,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2KHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceSurfaceCapabilities2KHR");;
     return vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return;
 }
@@ -16825,7 +17198,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR(
     uint32_t* pSurfaceFormatCount,
     VkSurfaceFormat2KHR* pSurfaceFormats)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceFormats2KHR");
     auto stream = mImpl->stream();
@@ -16932,9 +17305,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceSurfaceFormats2KHR");;
     return vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return;
 }
@@ -16948,7 +17321,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR(
     uint32_t* pPropertyCount,
     VkDisplayProperties2KHR* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceDisplayProperties2KHR");
     auto stream = mImpl->stream();
@@ -17042,9 +17415,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceDisplayProperties2KHR");;
     return vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return;
 }
@@ -17054,7 +17427,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
     uint32_t* pPropertyCount,
     VkDisplayPlaneProperties2KHR* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceDisplayPlaneProperties2KHR");
     auto stream = mImpl->stream();
@@ -17148,9 +17521,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceDisplayPlaneProperties2KHR");;
     return vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
 }
@@ -17161,7 +17534,7 @@ VkResult VkEncoder::vkGetDisplayModeProperties2KHR(
     uint32_t* pPropertyCount,
     VkDisplayModeProperties2KHR* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR encode");
     mImpl->log("start vkGetDisplayModeProperties2KHR");
     auto stream = mImpl->stream();
@@ -17263,9 +17636,9 @@ VkResult VkEncoder::vkGetDisplayModeProperties2KHR(
     AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR returnUnmarshal");
     VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDisplayModeProperties2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetDisplayModeProperties2KHR");;
     return vkGetDisplayModeProperties2KHR_VkResult_return;
 }
@@ -17275,7 +17648,7 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilities2KHR(
     const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
     VkDisplayPlaneCapabilities2KHR* pCapabilities)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR encode");
     mImpl->log("start vkGetDisplayPlaneCapabilities2KHR");
     auto stream = mImpl->stream();
@@ -17323,9 +17696,9 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilities2KHR(
     AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR returnUnmarshal");
     VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDisplayPlaneCapabilities2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetDisplayPlaneCapabilities2KHR");;
     return vkGetDisplayPlaneCapabilities2KHR_VkResult_return;
 }
@@ -17343,7 +17716,7 @@ void VkEncoder::vkGetImageMemoryRequirements2KHR(
     const VkImageMemoryRequirementsInfo2* pInfo,
     VkMemoryRequirements2* pMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR encode");
     mImpl->log("start vkGetImageMemoryRequirements2KHR");
     auto stream = mImpl->stream();
@@ -17389,6 +17762,9 @@ void VkEncoder::vkGetImageMemoryRequirements2KHR(
         transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements));
     }
     AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetImageMemoryRequirements2KHR");;
 }
 
@@ -17397,7 +17773,7 @@ void VkEncoder::vkGetBufferMemoryRequirements2KHR(
     const VkBufferMemoryRequirementsInfo2* pInfo,
     VkMemoryRequirements2* pMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR encode");
     mImpl->log("start vkGetBufferMemoryRequirements2KHR");
     auto stream = mImpl->stream();
@@ -17443,6 +17819,9 @@ void VkEncoder::vkGetBufferMemoryRequirements2KHR(
         transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements));
     }
     AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetBufferMemoryRequirements2KHR");;
 }
 
@@ -17452,7 +17831,7 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2KHR(
     uint32_t* pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR encode");
     mImpl->log("start vkGetImageSparseMemoryRequirements2KHR");
     auto stream = mImpl->stream();
@@ -17557,6 +17936,9 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2KHR(
         }
     }
     AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetImageSparseMemoryRequirements2KHR");;
 }
 
@@ -17570,7 +17952,7 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversionKHR(
     const VkAllocationCallbacks* pAllocator,
     VkSamplerYcbcrConversion* pYcbcrConversion)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR encode");
     mImpl->log("start vkCreateSamplerYcbcrConversionKHR");
     auto stream = mImpl->stream();
@@ -17650,9 +18032,9 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversionKHR(
     AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR returnUnmarshal");
     VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSamplerYcbcrConversionKHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateSamplerYcbcrConversionKHR");;
     return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
 }
@@ -17662,7 +18044,7 @@ void VkEncoder::vkDestroySamplerYcbcrConversionKHR(
     VkSamplerYcbcrConversion ycbcrConversion,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR encode");
     mImpl->log("start vkDestroySamplerYcbcrConversionKHR");
     auto stream = mImpl->stream();
@@ -17723,6 +18105,9 @@ void VkEncoder::vkDestroySamplerYcbcrConversionKHR(
     AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR readParams");
     AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroySamplerYcbcrConversionKHR");;
 }
 
@@ -17733,7 +18118,7 @@ VkResult VkEncoder::vkBindBufferMemory2KHR(
     uint32_t bindInfoCount,
     const VkBindBufferMemoryInfo* pBindInfos)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR encode");
     mImpl->log("start vkBindBufferMemory2KHR");
     auto stream = mImpl->stream();
@@ -17790,9 +18175,9 @@ VkResult VkEncoder::vkBindBufferMemory2KHR(
     AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR returnUnmarshal");
     VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkBindBufferMemory2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkBindBufferMemory2KHR");;
     return vkBindBufferMemory2KHR_VkResult_return;
 }
@@ -17802,7 +18187,7 @@ VkResult VkEncoder::vkBindImageMemory2KHR(
     uint32_t bindInfoCount,
     const VkBindImageMemoryInfo* pBindInfos)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkBindImageMemory2KHR encode");
     mImpl->log("start vkBindImageMemory2KHR");
     auto stream = mImpl->stream();
@@ -17859,9 +18244,9 @@ VkResult VkEncoder::vkBindImageMemory2KHR(
     AEMU_SCOPED_TRACE("vkBindImageMemory2KHR returnUnmarshal");
     VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkBindImageMemory2KHR_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkBindImageMemory2KHR");;
     return vkBindImageMemory2KHR_VkResult_return;
 }
@@ -17873,7 +18258,7 @@ void VkEncoder::vkGetDescriptorSetLayoutSupportKHR(
     const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
     VkDescriptorSetLayoutSupport* pSupport)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR encode");
     mImpl->log("start vkGetDescriptorSetLayoutSupportKHR");
     auto stream = mImpl->stream();
@@ -17919,6 +18304,9 @@ void VkEncoder::vkGetDescriptorSetLayoutSupportKHR(
         transform_fromhost_VkDescriptorSetLayoutSupport(mImpl->resources(), (VkDescriptorSetLayoutSupport*)(pSupport));
     }
     AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetDescriptorSetLayoutSupportKHR");;
 }
 
@@ -17933,7 +18321,7 @@ void VkEncoder::vkCmdDrawIndirectCountKHR(
     uint32_t maxDrawCount,
     uint32_t stride)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR encode");
     mImpl->log("start vkCmdDrawIndirectCountKHR");
     auto stream = mImpl->stream();
@@ -17991,6 +18379,9 @@ void VkEncoder::vkCmdDrawIndirectCountKHR(
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR readParams");
     AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDrawIndirectCountKHR");;
 }
 
@@ -18003,7 +18394,7 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountKHR(
     uint32_t maxDrawCount,
     uint32_t stride)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR encode");
     mImpl->log("start vkCmdDrawIndexedIndirectCountKHR");
     auto stream = mImpl->stream();
@@ -18061,12 +18452,17 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountKHR(
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR readParams");
     AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDrawIndexedIndirectCountKHR");;
 }
 
 #endif
 #ifdef VK_KHR_8bit_storage
 #endif
+#ifdef VK_KHR_shader_float16_int8
+#endif
 #ifdef VK_ANDROID_native_buffer
 VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID(
     VkDevice device,
@@ -18074,7 +18470,7 @@ VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID(
     VkImageUsageFlags imageUsage,
     int* grallocUsage)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID encode");
     mImpl->log("start vkGetSwapchainGrallocUsageANDROID");
     auto stream = mImpl->stream();
@@ -18113,9 +18509,9 @@ VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID(
     AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID returnUnmarshal");
     VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkGetSwapchainGrallocUsageANDROID_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetSwapchainGrallocUsageANDROID");;
     return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
 }
@@ -18127,7 +18523,7 @@ VkResult VkEncoder::vkAcquireImageANDROID(
     VkSemaphore semaphore,
     VkFence fence)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkAcquireImageANDROID encode");
     mImpl->log("start vkAcquireImageANDROID");
     auto stream = mImpl->stream();
@@ -18184,9 +18580,9 @@ VkResult VkEncoder::vkAcquireImageANDROID(
     AEMU_SCOPED_TRACE("vkAcquireImageANDROID returnUnmarshal");
     VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkAcquireImageANDROID_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkAcquireImageANDROID");;
     return vkAcquireImageANDROID_VkResult_return;
 }
@@ -18198,7 +18594,7 @@ VkResult VkEncoder::vkQueueSignalReleaseImageANDROID(
     VkImage image,
     int* pNativeFenceFd)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID encode");
     mImpl->log("start vkQueueSignalReleaseImageANDROID");
     auto stream = mImpl->stream();
@@ -18273,9 +18669,10 @@ VkResult VkEncoder::vkQueueSignalReleaseImageANDROID(
     AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID returnUnmarshal");
     VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkQueueSignalReleaseImageANDROID_VkResult_return, sizeof(VkResult));
+    stream->flush();
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkQueueSignalReleaseImageANDROID");;
     return vkQueueSignalReleaseImageANDROID_VkResult_return;
 }
@@ -18288,7 +18685,7 @@ VkResult VkEncoder::vkCreateDebugReportCallbackEXT(
     const VkAllocationCallbacks* pAllocator,
     VkDebugReportCallbackEXT* pCallback)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT encode");
     mImpl->log("start vkCreateDebugReportCallbackEXT");
     auto stream = mImpl->stream();
@@ -18368,9 +18765,9 @@ VkResult VkEncoder::vkCreateDebugReportCallbackEXT(
     AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT returnUnmarshal");
     VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDebugReportCallbackEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateDebugReportCallbackEXT");;
     return vkCreateDebugReportCallbackEXT_VkResult_return;
 }
@@ -18380,7 +18777,7 @@ void VkEncoder::vkDestroyDebugReportCallbackEXT(
     VkDebugReportCallbackEXT callback,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT encode");
     mImpl->log("start vkDestroyDebugReportCallbackEXT");
     auto stream = mImpl->stream();
@@ -18441,6 +18838,9 @@ void VkEncoder::vkDestroyDebugReportCallbackEXT(
     AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT readParams");
     AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDebugReportCallbackEXT((VkDebugReportCallbackEXT*)&callback);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyDebugReportCallbackEXT");;
 }
 
@@ -18454,7 +18854,7 @@ void VkEncoder::vkDebugReportMessageEXT(
     const char* pLayerPrefix,
     const char* pMessage)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDebugReportMessageEXT encode");
     mImpl->log("start vkDebugReportMessageEXT");
     auto stream = mImpl->stream();
@@ -18518,6 +18918,9 @@ void VkEncoder::vkDebugReportMessageEXT(
     stream->putString(local_pMessage);
     AEMU_SCOPED_TRACE("vkDebugReportMessageEXT readParams");
     AEMU_SCOPED_TRACE("vkDebugReportMessageEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDebugReportMessageEXT");;
 }
 
@@ -18539,7 +18942,7 @@ VkResult VkEncoder::vkDebugMarkerSetObjectTagEXT(
     VkDevice device,
     const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT encode");
     mImpl->log("start vkDebugMarkerSetObjectTagEXT");
     auto stream = mImpl->stream();
@@ -18580,9 +18983,9 @@ VkResult VkEncoder::vkDebugMarkerSetObjectTagEXT(
     AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT returnUnmarshal");
     VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
     stream->read(&vkDebugMarkerSetObjectTagEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkDebugMarkerSetObjectTagEXT");;
     return vkDebugMarkerSetObjectTagEXT_VkResult_return;
 }
@@ -18591,7 +18994,7 @@ VkResult VkEncoder::vkDebugMarkerSetObjectNameEXT(
     VkDevice device,
     const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT encode");
     mImpl->log("start vkDebugMarkerSetObjectNameEXT");
     auto stream = mImpl->stream();
@@ -18632,9 +19035,9 @@ VkResult VkEncoder::vkDebugMarkerSetObjectNameEXT(
     AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT returnUnmarshal");
     VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
     stream->read(&vkDebugMarkerSetObjectNameEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkDebugMarkerSetObjectNameEXT");;
     return vkDebugMarkerSetObjectNameEXT_VkResult_return;
 }
@@ -18643,7 +19046,7 @@ void VkEncoder::vkCmdDebugMarkerBeginEXT(
     VkCommandBuffer commandBuffer,
     const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT encode");
     mImpl->log("start vkCmdDebugMarkerBeginEXT");
     auto stream = mImpl->stream();
@@ -18682,13 +19085,16 @@ void VkEncoder::vkCmdDebugMarkerBeginEXT(
     marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
     AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT readParams");
     AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDebugMarkerBeginEXT");;
 }
 
 void VkEncoder::vkCmdDebugMarkerEndEXT(
     VkCommandBuffer commandBuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT encode");
     mImpl->log("start vkCmdDebugMarkerEndEXT");
     auto stream = mImpl->stream();
@@ -18714,6 +19120,9 @@ void VkEncoder::vkCmdDebugMarkerEndEXT(
     stream->write((uint64_t*)&cgen_var_1224, 1 * 8);
     AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT readParams");
     AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDebugMarkerEndEXT");;
 }
 
@@ -18721,7 +19130,7 @@ void VkEncoder::vkCmdDebugMarkerInsertEXT(
     VkCommandBuffer commandBuffer,
     const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT encode");
     mImpl->log("start vkCmdDebugMarkerInsertEXT");
     auto stream = mImpl->stream();
@@ -18760,6 +19169,9 @@ void VkEncoder::vkCmdDebugMarkerInsertEXT(
     marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
     AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT readParams");
     AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDebugMarkerInsertEXT");;
 }
 
@@ -18778,7 +19190,7 @@ void VkEncoder::vkCmdDrawIndirectCountAMD(
     uint32_t maxDrawCount,
     uint32_t stride)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD encode");
     mImpl->log("start vkCmdDrawIndirectCountAMD");
     auto stream = mImpl->stream();
@@ -18836,6 +19248,9 @@ void VkEncoder::vkCmdDrawIndirectCountAMD(
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD readParams");
     AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDrawIndirectCountAMD");;
 }
 
@@ -18848,7 +19263,7 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountAMD(
     uint32_t maxDrawCount,
     uint32_t stride)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD encode");
     mImpl->log("start vkCmdDrawIndexedIndirectCountAMD");
     auto stream = mImpl->stream();
@@ -18906,6 +19321,9 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountAMD(
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD readParams");
     AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdDrawIndexedIndirectCountAMD");;
 }
 
@@ -18927,7 +19345,7 @@ VkResult VkEncoder::vkGetShaderInfoAMD(
     size_t* pInfoSize,
     void* pInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetShaderInfoAMD encode");
     mImpl->log("start vkGetShaderInfoAMD");
     auto stream = mImpl->stream();
@@ -19023,9 +19441,9 @@ VkResult VkEncoder::vkGetShaderInfoAMD(
     AEMU_SCOPED_TRACE("vkGetShaderInfoAMD returnUnmarshal");
     VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
     stream->read(&vkGetShaderInfoAMD_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetShaderInfoAMD");;
     return vkGetShaderInfoAMD_VkResult_return;
 }
@@ -19046,7 +19464,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
     VkExternalMemoryHandleTypeFlagsNV externalHandleType,
     VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV encode");
     mImpl->log("start vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
     auto stream = mImpl->stream();
@@ -19105,9 +19523,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV returnUnmarshal");
     VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceExternalImageFormatPropertiesNV");;
     return vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return;
 }
@@ -19122,7 +19540,7 @@ VkResult VkEncoder::vkGetMemoryWin32HandleNV(
     VkExternalMemoryHandleTypeFlagsNV handleType,
     HANDLE* pHandle)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV encode");
     mImpl->log("start vkGetMemoryWin32HandleNV");
     auto stream = mImpl->stream();
@@ -19166,9 +19584,9 @@ VkResult VkEncoder::vkGetMemoryWin32HandleNV(
     AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV returnUnmarshal");
     VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryWin32HandleNV_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetMemoryWin32HandleNV");;
     return vkGetMemoryWin32HandleNV_VkResult_return;
 }
@@ -19185,7 +19603,7 @@ VkResult VkEncoder::vkCreateViSurfaceNN(
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateViSurfaceNN encode");
     mImpl->log("start vkCreateViSurfaceNN");
     auto stream = mImpl->stream();
@@ -19263,9 +19681,9 @@ VkResult VkEncoder::vkCreateViSurfaceNN(
     AEMU_SCOPED_TRACE("vkCreateViSurfaceNN returnUnmarshal");
     VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
     stream->read(&vkCreateViSurfaceNN_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateViSurfaceNN");;
     return vkCreateViSurfaceNN_VkResult_return;
 }
@@ -19280,7 +19698,7 @@ void VkEncoder::vkCmdBeginConditionalRenderingEXT(
     VkCommandBuffer commandBuffer,
     const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT encode");
     mImpl->log("start vkCmdBeginConditionalRenderingEXT");
     auto stream = mImpl->stream();
@@ -19319,13 +19737,16 @@ void VkEncoder::vkCmdBeginConditionalRenderingEXT(
     marshal_VkConditionalRenderingBeginInfoEXT(stream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
     AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT readParams");
     AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdBeginConditionalRenderingEXT");;
 }
 
 void VkEncoder::vkCmdEndConditionalRenderingEXT(
     VkCommandBuffer commandBuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT encode");
     mImpl->log("start vkCmdEndConditionalRenderingEXT");
     auto stream = mImpl->stream();
@@ -19351,6 +19772,9 @@ void VkEncoder::vkCmdEndConditionalRenderingEXT(
     stream->write((uint64_t*)&cgen_var_1268, 1 * 8);
     AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT readParams");
     AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdEndConditionalRenderingEXT");;
 }
 
@@ -19360,7 +19784,7 @@ void VkEncoder::vkCmdProcessCommandsNVX(
     VkCommandBuffer commandBuffer,
     const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX encode");
     mImpl->log("start vkCmdProcessCommandsNVX");
     auto stream = mImpl->stream();
@@ -19399,6 +19823,9 @@ void VkEncoder::vkCmdProcessCommandsNVX(
     marshal_VkCmdProcessCommandsInfoNVX(stream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
     AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX readParams");
     AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdProcessCommandsNVX");;
 }
 
@@ -19406,7 +19833,7 @@ void VkEncoder::vkCmdReserveSpaceForCommandsNVX(
     VkCommandBuffer commandBuffer,
     const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX encode");
     mImpl->log("start vkCmdReserveSpaceForCommandsNVX");
     auto stream = mImpl->stream();
@@ -19445,6 +19872,9 @@ void VkEncoder::vkCmdReserveSpaceForCommandsNVX(
     marshal_VkCmdReserveSpaceForCommandsInfoNVX(stream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
     AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX readParams");
     AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdReserveSpaceForCommandsNVX");;
 }
 
@@ -19454,7 +19884,7 @@ VkResult VkEncoder::vkCreateIndirectCommandsLayoutNVX(
     const VkAllocationCallbacks* pAllocator,
     VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX encode");
     mImpl->log("start vkCreateIndirectCommandsLayoutNVX");
     auto stream = mImpl->stream();
@@ -19534,9 +19964,9 @@ VkResult VkEncoder::vkCreateIndirectCommandsLayoutNVX(
     AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX returnUnmarshal");
     VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
     stream->read(&vkCreateIndirectCommandsLayoutNVX_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateIndirectCommandsLayoutNVX");;
     return vkCreateIndirectCommandsLayoutNVX_VkResult_return;
 }
@@ -19546,7 +19976,7 @@ void VkEncoder::vkDestroyIndirectCommandsLayoutNVX(
     VkIndirectCommandsLayoutNVX indirectCommandsLayout,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX encode");
     mImpl->log("start vkDestroyIndirectCommandsLayoutNVX");
     auto stream = mImpl->stream();
@@ -19607,6 +20037,9 @@ void VkEncoder::vkDestroyIndirectCommandsLayoutNVX(
     AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX readParams");
     AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&indirectCommandsLayout);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyIndirectCommandsLayoutNVX");;
 }
 
@@ -19616,7 +20049,7 @@ VkResult VkEncoder::vkCreateObjectTableNVX(
     const VkAllocationCallbacks* pAllocator,
     VkObjectTableNVX* pObjectTable)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateObjectTableNVX encode");
     mImpl->log("start vkCreateObjectTableNVX");
     auto stream = mImpl->stream();
@@ -19696,9 +20129,9 @@ VkResult VkEncoder::vkCreateObjectTableNVX(
     AEMU_SCOPED_TRACE("vkCreateObjectTableNVX returnUnmarshal");
     VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
     stream->read(&vkCreateObjectTableNVX_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateObjectTableNVX");;
     return vkCreateObjectTableNVX_VkResult_return;
 }
@@ -19708,7 +20141,7 @@ void VkEncoder::vkDestroyObjectTableNVX(
     VkObjectTableNVX objectTable,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX encode");
     mImpl->log("start vkDestroyObjectTableNVX");
     auto stream = mImpl->stream();
@@ -19769,6 +20202,9 @@ void VkEncoder::vkDestroyObjectTableNVX(
     AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX readParams");
     AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&objectTable);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyObjectTableNVX");;
 }
 
@@ -19779,7 +20215,7 @@ VkResult VkEncoder::vkRegisterObjectsNVX(
     const VkObjectTableEntryNVX* const* ppObjectTableEntries,
     const uint32_t* pObjectIndices)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkRegisterObjectsNVX encode");
     mImpl->log("start vkRegisterObjectsNVX");
     auto stream = mImpl->stream();
@@ -19832,9 +20268,9 @@ VkResult VkEncoder::vkRegisterObjectsNVX(
     AEMU_SCOPED_TRACE("vkRegisterObjectsNVX returnUnmarshal");
     VkResult vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterObjectsNVX_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkRegisterObjectsNVX");;
     return vkRegisterObjectsNVX_VkResult_return;
 }
@@ -19846,7 +20282,7 @@ VkResult VkEncoder::vkUnregisterObjectsNVX(
     const VkObjectEntryTypeNVX* pObjectEntryTypes,
     const uint32_t* pObjectIndices)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX encode");
     mImpl->log("start vkUnregisterObjectsNVX");
     auto stream = mImpl->stream();
@@ -19902,9 +20338,9 @@ VkResult VkEncoder::vkUnregisterObjectsNVX(
     AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX returnUnmarshal");
     VkResult vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
     stream->read(&vkUnregisterObjectsNVX_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkUnregisterObjectsNVX");;
     return vkUnregisterObjectsNVX_VkResult_return;
 }
@@ -19914,7 +20350,7 @@ void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
     VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
     VkDeviceGeneratedCommandsLimitsNVX* pLimits)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX encode");
     mImpl->log("start vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
     auto stream = mImpl->stream();
@@ -19954,6 +20390,9 @@ void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
         transform_fromhost_VkDeviceGeneratedCommandsLimitsNVX(mImpl->resources(), (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");;
 }
 
@@ -19965,7 +20404,7 @@ void VkEncoder::vkCmdSetViewportWScalingNV(
     uint32_t viewportCount,
     const VkViewportWScalingNV* pViewportWScalings)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV encode");
     mImpl->log("start vkCmdSetViewportWScalingNV");
     auto stream = mImpl->stream();
@@ -20024,6 +20463,9 @@ void VkEncoder::vkCmdSetViewportWScalingNV(
     }
     AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV readParams");
     AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetViewportWScalingNV");;
 }
 
@@ -20033,7 +20475,7 @@ VkResult VkEncoder::vkReleaseDisplayEXT(
     VkPhysicalDevice physicalDevice,
     VkDisplayKHR display)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkReleaseDisplayEXT encode");
     mImpl->log("start vkReleaseDisplayEXT");
     auto stream = mImpl->stream();
@@ -20069,9 +20511,9 @@ VkResult VkEncoder::vkReleaseDisplayEXT(
     AEMU_SCOPED_TRACE("vkReleaseDisplayEXT returnUnmarshal");
     VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
     stream->read(&vkReleaseDisplayEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkReleaseDisplayEXT");;
     return vkReleaseDisplayEXT_VkResult_return;
 }
@@ -20083,7 +20525,7 @@ VkResult VkEncoder::vkAcquireXlibDisplayEXT(
     Display* dpy,
     VkDisplayKHR display)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT encode");
     mImpl->log("start vkAcquireXlibDisplayEXT");
     auto stream = mImpl->stream();
@@ -20122,9 +20564,9 @@ VkResult VkEncoder::vkAcquireXlibDisplayEXT(
     AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT returnUnmarshal");
     VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
     stream->read(&vkAcquireXlibDisplayEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkAcquireXlibDisplayEXT");;
     return vkAcquireXlibDisplayEXT_VkResult_return;
 }
@@ -20135,7 +20577,7 @@ VkResult VkEncoder::vkGetRandROutputDisplayEXT(
     RROutput rrOutput,
     VkDisplayKHR* pDisplay)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT encode");
     mImpl->log("start vkGetRandROutputDisplayEXT");
     auto stream = mImpl->stream();
@@ -20181,9 +20623,9 @@ VkResult VkEncoder::vkGetRandROutputDisplayEXT(
     AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT returnUnmarshal");
     VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetRandROutputDisplayEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetRandROutputDisplayEXT");;
     return vkGetRandROutputDisplayEXT_VkResult_return;
 }
@@ -20195,7 +20637,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2EXT(
     VkSurfaceKHR surface,
     VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilities2EXT");
     auto stream = mImpl->stream();
@@ -20238,9 +20680,9 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2EXT(
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPhysicalDeviceSurfaceCapabilities2EXT");;
     return vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return;
 }
@@ -20252,7 +20694,7 @@ VkResult VkEncoder::vkDisplayPowerControlEXT(
     VkDisplayKHR display,
     const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT encode");
     mImpl->log("start vkDisplayPowerControlEXT");
     auto stream = mImpl->stream();
@@ -20301,9 +20743,9 @@ VkResult VkEncoder::vkDisplayPowerControlEXT(
     AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT returnUnmarshal");
     VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
     stream->read(&vkDisplayPowerControlEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkDisplayPowerControlEXT");;
     return vkDisplayPowerControlEXT_VkResult_return;
 }
@@ -20314,7 +20756,7 @@ VkResult VkEncoder::vkRegisterDeviceEventEXT(
     const VkAllocationCallbacks* pAllocator,
     VkFence* pFence)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT encode");
     mImpl->log("start vkRegisterDeviceEventEXT");
     auto stream = mImpl->stream();
@@ -20392,9 +20834,9 @@ VkResult VkEncoder::vkRegisterDeviceEventEXT(
     AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT returnUnmarshal");
     VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterDeviceEventEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkRegisterDeviceEventEXT");;
     return vkRegisterDeviceEventEXT_VkResult_return;
 }
@@ -20406,7 +20848,7 @@ VkResult VkEncoder::vkRegisterDisplayEventEXT(
     const VkAllocationCallbacks* pAllocator,
     VkFence* pFence)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT encode");
     mImpl->log("start vkRegisterDisplayEventEXT");
     auto stream = mImpl->stream();
@@ -20492,9 +20934,9 @@ VkResult VkEncoder::vkRegisterDisplayEventEXT(
     AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT returnUnmarshal");
     VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterDisplayEventEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkRegisterDisplayEventEXT");;
     return vkRegisterDisplayEventEXT_VkResult_return;
 }
@@ -20505,7 +20947,7 @@ VkResult VkEncoder::vkGetSwapchainCounterEXT(
     VkSurfaceCounterFlagBitsEXT counter,
     uint64_t* pCounterValue)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT encode");
     mImpl->log("start vkGetSwapchainCounterEXT");
     auto stream = mImpl->stream();
@@ -20548,9 +20990,9 @@ VkResult VkEncoder::vkGetSwapchainCounterEXT(
     AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT returnUnmarshal");
     VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetSwapchainCounterEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetSwapchainCounterEXT");;
     return vkGetSwapchainCounterEXT_VkResult_return;
 }
@@ -20562,7 +21004,7 @@ VkResult VkEncoder::vkGetRefreshCycleDurationGOOGLE(
     VkSwapchainKHR swapchain,
     VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE encode");
     mImpl->log("start vkGetRefreshCycleDurationGOOGLE");
     auto stream = mImpl->stream();
@@ -20605,9 +21047,9 @@ VkResult VkEncoder::vkGetRefreshCycleDurationGOOGLE(
     AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE returnUnmarshal");
     VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkGetRefreshCycleDurationGOOGLE_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetRefreshCycleDurationGOOGLE");;
     return vkGetRefreshCycleDurationGOOGLE_VkResult_return;
 }
@@ -20618,7 +21060,7 @@ VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE(
     uint32_t* pPresentationTimingCount,
     VkPastPresentationTimingGOOGLE* pPresentationTimings)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE encode");
     mImpl->log("start vkGetPastPresentationTimingGOOGLE");
     auto stream = mImpl->stream();
@@ -20720,9 +21162,9 @@ VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE(
     AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE returnUnmarshal");
     VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkGetPastPresentationTimingGOOGLE_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetPastPresentationTimingGOOGLE");;
     return vkGetPastPresentationTimingGOOGLE_VkResult_return;
 }
@@ -20745,7 +21187,7 @@ void VkEncoder::vkCmdSetDiscardRectangleEXT(
     uint32_t discardRectangleCount,
     const VkRect2D* pDiscardRectangles)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT encode");
     mImpl->log("start vkCmdSetDiscardRectangleEXT");
     auto stream = mImpl->stream();
@@ -20804,6 +21246,9 @@ void VkEncoder::vkCmdSetDiscardRectangleEXT(
     }
     AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT readParams");
     AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetDiscardRectangleEXT");;
 }
 
@@ -20819,7 +21264,7 @@ void VkEncoder::vkSetHdrMetadataEXT(
     const VkSwapchainKHR* pSwapchains,
     const VkHdrMetadataEXT* pMetadata)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT encode");
     mImpl->log("start vkSetHdrMetadataEXT");
     auto stream = mImpl->stream();
@@ -20894,6 +21339,9 @@ void VkEncoder::vkSetHdrMetadataEXT(
     }
     AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT readParams");
     AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkSetHdrMetadataEXT");;
 }
 
@@ -20905,7 +21353,7 @@ VkResult VkEncoder::vkCreateIOSSurfaceMVK(
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK encode");
     mImpl->log("start vkCreateIOSSurfaceMVK");
     auto stream = mImpl->stream();
@@ -20983,9 +21431,9 @@ VkResult VkEncoder::vkCreateIOSSurfaceMVK(
     AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK returnUnmarshal");
     VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
     stream->read(&vkCreateIOSSurfaceMVK_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateIOSSurfaceMVK");;
     return vkCreateIOSSurfaceMVK_VkResult_return;
 }
@@ -20998,7 +21446,7 @@ VkResult VkEncoder::vkCreateMacOSSurfaceMVK(
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK encode");
     mImpl->log("start vkCreateMacOSSurfaceMVK");
     auto stream = mImpl->stream();
@@ -21076,9 +21524,9 @@ VkResult VkEncoder::vkCreateMacOSSurfaceMVK(
     AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK returnUnmarshal");
     VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
     stream->read(&vkCreateMacOSSurfaceMVK_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateMacOSSurfaceMVK");;
     return vkCreateMacOSSurfaceMVK_VkResult_return;
 }
@@ -21093,7 +21541,7 @@ VkResult VkEncoder::vkSetDebugUtilsObjectNameEXT(
     VkDevice device,
     const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT encode");
     mImpl->log("start vkSetDebugUtilsObjectNameEXT");
     auto stream = mImpl->stream();
@@ -21134,9 +21582,9 @@ VkResult VkEncoder::vkSetDebugUtilsObjectNameEXT(
     AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT returnUnmarshal");
     VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
     stream->read(&vkSetDebugUtilsObjectNameEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkSetDebugUtilsObjectNameEXT");;
     return vkSetDebugUtilsObjectNameEXT_VkResult_return;
 }
@@ -21145,7 +21593,7 @@ VkResult VkEncoder::vkSetDebugUtilsObjectTagEXT(
     VkDevice device,
     const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT encode");
     mImpl->log("start vkSetDebugUtilsObjectTagEXT");
     auto stream = mImpl->stream();
@@ -21186,9 +21634,9 @@ VkResult VkEncoder::vkSetDebugUtilsObjectTagEXT(
     AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT returnUnmarshal");
     VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
     stream->read(&vkSetDebugUtilsObjectTagEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkSetDebugUtilsObjectTagEXT");;
     return vkSetDebugUtilsObjectTagEXT_VkResult_return;
 }
@@ -21197,7 +21645,7 @@ void VkEncoder::vkQueueBeginDebugUtilsLabelEXT(
     VkQueue queue,
     const VkDebugUtilsLabelEXT* pLabelInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT encode");
     mImpl->log("start vkQueueBeginDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
@@ -21236,13 +21684,16 @@ void VkEncoder::vkQueueBeginDebugUtilsLabelEXT(
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT readParams");
     AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkQueueBeginDebugUtilsLabelEXT");;
 }
 
 void VkEncoder::vkQueueEndDebugUtilsLabelEXT(
     VkQueue queue)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT encode");
     mImpl->log("start vkQueueEndDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
@@ -21268,6 +21719,9 @@ void VkEncoder::vkQueueEndDebugUtilsLabelEXT(
     stream->write((uint64_t*)&cgen_var_1393, 1 * 8);
     AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT readParams");
     AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkQueueEndDebugUtilsLabelEXT");;
 }
 
@@ -21275,7 +21729,7 @@ void VkEncoder::vkQueueInsertDebugUtilsLabelEXT(
     VkQueue queue,
     const VkDebugUtilsLabelEXT* pLabelInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT encode");
     mImpl->log("start vkQueueInsertDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
@@ -21314,6 +21768,9 @@ void VkEncoder::vkQueueInsertDebugUtilsLabelEXT(
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT readParams");
     AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkQueueInsertDebugUtilsLabelEXT");;
 }
 
@@ -21321,7 +21778,7 @@ void VkEncoder::vkCmdBeginDebugUtilsLabelEXT(
     VkCommandBuffer commandBuffer,
     const VkDebugUtilsLabelEXT* pLabelInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT encode");
     mImpl->log("start vkCmdBeginDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
@@ -21360,13 +21817,16 @@ void VkEncoder::vkCmdBeginDebugUtilsLabelEXT(
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT readParams");
     AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdBeginDebugUtilsLabelEXT");;
 }
 
 void VkEncoder::vkCmdEndDebugUtilsLabelEXT(
     VkCommandBuffer commandBuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT encode");
     mImpl->log("start vkCmdEndDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
@@ -21392,6 +21852,9 @@ void VkEncoder::vkCmdEndDebugUtilsLabelEXT(
     stream->write((uint64_t*)&cgen_var_1399, 1 * 8);
     AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT readParams");
     AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdEndDebugUtilsLabelEXT");;
 }
 
@@ -21399,7 +21862,7 @@ void VkEncoder::vkCmdInsertDebugUtilsLabelEXT(
     VkCommandBuffer commandBuffer,
     const VkDebugUtilsLabelEXT* pLabelInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT encode");
     mImpl->log("start vkCmdInsertDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
@@ -21438,6 +21901,9 @@ void VkEncoder::vkCmdInsertDebugUtilsLabelEXT(
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT readParams");
     AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdInsertDebugUtilsLabelEXT");;
 }
 
@@ -21447,7 +21913,7 @@ VkResult VkEncoder::vkCreateDebugUtilsMessengerEXT(
     const VkAllocationCallbacks* pAllocator,
     VkDebugUtilsMessengerEXT* pMessenger)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT encode");
     mImpl->log("start vkCreateDebugUtilsMessengerEXT");
     auto stream = mImpl->stream();
@@ -21527,9 +21993,9 @@ VkResult VkEncoder::vkCreateDebugUtilsMessengerEXT(
     AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT returnUnmarshal");
     VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDebugUtilsMessengerEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateDebugUtilsMessengerEXT");;
     return vkCreateDebugUtilsMessengerEXT_VkResult_return;
 }
@@ -21539,7 +22005,7 @@ void VkEncoder::vkDestroyDebugUtilsMessengerEXT(
     VkDebugUtilsMessengerEXT messenger,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT encode");
     mImpl->log("start vkDestroyDebugUtilsMessengerEXT");
     auto stream = mImpl->stream();
@@ -21600,6 +22066,9 @@ void VkEncoder::vkDestroyDebugUtilsMessengerEXT(
     AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT readParams");
     AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDebugUtilsMessengerEXT((VkDebugUtilsMessengerEXT*)&messenger);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyDebugUtilsMessengerEXT");;
 }
 
@@ -21609,7 +22078,7 @@ void VkEncoder::vkSubmitDebugUtilsMessageEXT(
     VkDebugUtilsMessageTypeFlagsEXT messageTypes,
     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT encode");
     mImpl->log("start vkSubmitDebugUtilsMessageEXT");
     auto stream = mImpl->stream();
@@ -21656,6 +22125,9 @@ void VkEncoder::vkSubmitDebugUtilsMessageEXT(
     marshal_VkDebugUtilsMessengerCallbackDataEXT(stream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
     AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT readParams");
     AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkSubmitDebugUtilsMessageEXT");;
 }
 
@@ -21666,7 +22138,7 @@ VkResult VkEncoder::vkGetAndroidHardwareBufferPropertiesANDROID(
     const AHardwareBuffer* buffer,
     VkAndroidHardwareBufferPropertiesANDROID* pProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID encode");
     mImpl->log("start vkGetAndroidHardwareBufferPropertiesANDROID");
     auto stream = mImpl->stream();
@@ -21709,9 +22181,9 @@ VkResult VkEncoder::vkGetAndroidHardwareBufferPropertiesANDROID(
     AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID returnUnmarshal");
     VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetAndroidHardwareBufferPropertiesANDROID");;
     return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
 }
@@ -21721,7 +22193,7 @@ VkResult VkEncoder::vkGetMemoryAndroidHardwareBufferANDROID(
     const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
     AHardwareBuffer** pBuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID encode");
     mImpl->log("start vkGetMemoryAndroidHardwareBufferANDROID");
     auto stream = mImpl->stream();
@@ -21765,9 +22237,9 @@ VkResult VkEncoder::vkGetMemoryAndroidHardwareBufferANDROID(
     AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID returnUnmarshal");
     VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetMemoryAndroidHardwareBufferANDROID");;
     return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
 }
@@ -21788,7 +22260,7 @@ void VkEncoder::vkCmdSetSampleLocationsEXT(
     VkCommandBuffer commandBuffer,
     const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT encode");
     mImpl->log("start vkCmdSetSampleLocationsEXT");
     auto stream = mImpl->stream();
@@ -21827,6 +22299,9 @@ void VkEncoder::vkCmdSetSampleLocationsEXT(
     marshal_VkSampleLocationsInfoEXT(stream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
     AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT readParams");
     AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetSampleLocationsEXT");;
 }
 
@@ -21835,7 +22310,7 @@ void VkEncoder::vkGetPhysicalDeviceMultisamplePropertiesEXT(
     VkSampleCountFlagBits samples,
     VkMultisamplePropertiesEXT* pMultisampleProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT encode");
     mImpl->log("start vkGetPhysicalDeviceMultisamplePropertiesEXT");
     auto stream = mImpl->stream();
@@ -21872,6 +22347,9 @@ void VkEncoder::vkGetPhysicalDeviceMultisamplePropertiesEXT(
         transform_fromhost_VkMultisamplePropertiesEXT(mImpl->resources(), (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
     }
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetPhysicalDeviceMultisamplePropertiesEXT");;
 }
 
@@ -21893,7 +22371,7 @@ VkResult VkEncoder::vkCreateValidationCacheEXT(
     const VkAllocationCallbacks* pAllocator,
     VkValidationCacheEXT* pValidationCache)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT encode");
     mImpl->log("start vkCreateValidationCacheEXT");
     auto stream = mImpl->stream();
@@ -21973,9 +22451,9 @@ VkResult VkEncoder::vkCreateValidationCacheEXT(
     AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT returnUnmarshal");
     VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
     stream->read(&vkCreateValidationCacheEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateValidationCacheEXT");;
     return vkCreateValidationCacheEXT_VkResult_return;
 }
@@ -21985,7 +22463,7 @@ void VkEncoder::vkDestroyValidationCacheEXT(
     VkValidationCacheEXT validationCache,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT encode");
     mImpl->log("start vkDestroyValidationCacheEXT");
     auto stream = mImpl->stream();
@@ -22046,6 +22524,9 @@ void VkEncoder::vkDestroyValidationCacheEXT(
     AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT readParams");
     AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&validationCache);
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkDestroyValidationCacheEXT");;
 }
 
@@ -22055,7 +22536,7 @@ VkResult VkEncoder::vkMergeValidationCachesEXT(
     uint32_t srcCacheCount,
     const VkValidationCacheEXT* pSrcCaches)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT encode");
     mImpl->log("start vkMergeValidationCachesEXT");
     auto stream = mImpl->stream();
@@ -22115,9 +22596,9 @@ VkResult VkEncoder::vkMergeValidationCachesEXT(
     AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT returnUnmarshal");
     VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
     stream->read(&vkMergeValidationCachesEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkMergeValidationCachesEXT");;
     return vkMergeValidationCachesEXT_VkResult_return;
 }
@@ -22128,7 +22609,7 @@ VkResult VkEncoder::vkGetValidationCacheDataEXT(
     size_t* pDataSize,
     void* pData)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT encode");
     mImpl->log("start vkGetValidationCacheDataEXT");
     auto stream = mImpl->stream();
@@ -22216,9 +22697,9 @@ VkResult VkEncoder::vkGetValidationCacheDataEXT(
     AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT returnUnmarshal");
     VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetValidationCacheDataEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetValidationCacheDataEXT");;
     return vkGetValidationCacheDataEXT_VkResult_return;
 }
@@ -22237,7 +22718,7 @@ VkResult VkEncoder::vkGetMemoryHostPointerPropertiesEXT(
     const void* pHostPointer,
     VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT encode");
     mImpl->log("start vkGetMemoryHostPointerPropertiesEXT");
     auto stream = mImpl->stream();
@@ -22296,9 +22777,9 @@ VkResult VkEncoder::vkGetMemoryHostPointerPropertiesEXT(
     AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT returnUnmarshal");
     VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryHostPointerPropertiesEXT_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetMemoryHostPointerPropertiesEXT");;
     return vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
 }
@@ -22312,7 +22793,7 @@ void VkEncoder::vkCmdWriteBufferMarkerAMD(
     VkDeviceSize dstOffset,
     uint32_t marker)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD encode");
     mImpl->log("start vkCmdWriteBufferMarkerAMD");
     auto stream = mImpl->stream();
@@ -22358,6 +22839,9 @@ void VkEncoder::vkCmdWriteBufferMarkerAMD(
     stream->write((uint32_t*)&local_marker, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD readParams");
     AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdWriteBufferMarkerAMD");;
 }
 
@@ -22373,7 +22857,7 @@ void VkEncoder::vkCmdSetCheckpointNV(
     VkCommandBuffer commandBuffer,
     const void* pCheckpointMarker)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV encode");
     mImpl->log("start vkCmdSetCheckpointNV");
     auto stream = mImpl->stream();
@@ -22419,6 +22903,9 @@ void VkEncoder::vkCmdSetCheckpointNV(
     }
     AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV readParams");
     AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCmdSetCheckpointNV");;
 }
 
@@ -22427,7 +22914,7 @@ void VkEncoder::vkGetQueueCheckpointDataNV(
     uint32_t* pCheckpointDataCount,
     VkCheckpointDataNV* pCheckpointData)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV encode");
     mImpl->log("start vkGetQueueCheckpointDataNV");
     auto stream = mImpl->stream();
@@ -22519,6 +23006,9 @@ void VkEncoder::vkGetQueueCheckpointDataNV(
         }
     }
     AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkGetQueueCheckpointDataNV");;
 }
 
@@ -22529,12 +23019,10 @@ VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE(
     VkDeviceMemory memory,
     uint64_t* pAddress)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE encode");
     mImpl->log("start vkMapMemoryIntoAddressSpaceGOOGLE");
-    encoderLock.unlock();
     mImpl->resources()->on_vkMapMemoryIntoAddressSpaceGOOGLE_pre(this, VK_SUCCESS, device, memory, pAddress);
-    encoderLock.lock();
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
     auto resources = mImpl->resources();
@@ -22594,12 +23082,10 @@ VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE(
     AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE returnUnmarshal");
     VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, sizeof(VkResult));
+    mImpl->resources()->on_vkMapMemoryIntoAddressSpaceGOOGLE(this, vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, device, memory, pAddress);
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
-    encoderLock.unlock();
-    mImpl->resources()->on_vkMapMemoryIntoAddressSpaceGOOGLE(this, vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, device, memory, pAddress);
-    encoderLock.lock();
     mImpl->log("finish vkMapMemoryIntoAddressSpaceGOOGLE");;
     return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
 }
@@ -22611,7 +23097,7 @@ VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE(
     VkImage image,
     uint32_t colorBuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE encode");
     mImpl->log("start vkRegisterImageColorBufferGOOGLE");
     auto stream = mImpl->stream();
@@ -22651,9 +23137,9 @@ VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE(
     AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE returnUnmarshal");
     VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterImageColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkRegisterImageColorBufferGOOGLE");;
     return vkRegisterImageColorBufferGOOGLE_VkResult_return;
 }
@@ -22663,7 +23149,7 @@ VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE(
     VkBuffer buffer,
     uint32_t colorBuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE encode");
     mImpl->log("start vkRegisterBufferColorBufferGOOGLE");
     auto stream = mImpl->stream();
@@ -22703,9 +23189,9 @@ VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE(
     AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE returnUnmarshal");
     VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterBufferColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkRegisterBufferColorBufferGOOGLE");;
     return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
 }
@@ -22726,7 +23212,7 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
     const VkDescriptorBufferInfo* pBufferInfos,
     const VkBufferView* pBufferViews)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE encode");
     mImpl->log("start vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
     auto stream = mImpl->stream();
@@ -22946,6 +23432,9 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
     }
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE readParams");
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkUpdateDescriptorSetWithTemplateSizedGOOGLE");;
 }
 
@@ -22955,7 +23444,7 @@ void VkEncoder::vkBeginCommandBufferAsyncGOOGLE(
     VkCommandBuffer commandBuffer,
     const VkCommandBufferBeginInfo* pBeginInfo)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE encode");
     mImpl->log("start vkBeginCommandBufferAsyncGOOGLE");
     auto stream = mImpl->stream();
@@ -22994,13 +23483,16 @@ void VkEncoder::vkBeginCommandBufferAsyncGOOGLE(
     marshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
     AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE readParams");
     AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkBeginCommandBufferAsyncGOOGLE");;
 }
 
 void VkEncoder::vkEndCommandBufferAsyncGOOGLE(
     VkCommandBuffer commandBuffer)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE encode");
     mImpl->log("start vkEndCommandBufferAsyncGOOGLE");
     auto stream = mImpl->stream();
@@ -23026,6 +23518,10 @@ void VkEncoder::vkEndCommandBufferAsyncGOOGLE(
     stream->write((uint64_t*)&cgen_var_1515, 1 * 8);
     AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE readParams");
     AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE returnUnmarshal");
+    stream->flush();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkEndCommandBufferAsyncGOOGLE");;
 }
 
@@ -23033,7 +23529,7 @@ void VkEncoder::vkResetCommandBufferAsyncGOOGLE(
     VkCommandBuffer commandBuffer,
     VkCommandBufferResetFlags flags)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE encode");
     mImpl->log("start vkResetCommandBufferAsyncGOOGLE");
     auto stream = mImpl->stream();
@@ -23063,6 +23559,9 @@ void VkEncoder::vkResetCommandBufferAsyncGOOGLE(
     stream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
     AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE readParams");
     AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkResetCommandBufferAsyncGOOGLE");;
 }
 
@@ -23071,7 +23570,7 @@ void VkEncoder::vkCommandBufferHostSyncGOOGLE(
     uint32_t needHostSync,
     uint32_t sequenceNumber)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE encode");
     mImpl->log("start vkCommandBufferHostSyncGOOGLE");
     auto stream = mImpl->stream();
@@ -23105,6 +23604,9 @@ void VkEncoder::vkCommandBufferHostSyncGOOGLE(
     stream->write((uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
     AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE readParams");
     AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
     mImpl->log("finish vkCommandBufferHostSyncGOOGLE");;
 }
 
@@ -23117,7 +23619,7 @@ VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE(
     VkImage* pImage,
     VkMemoryRequirements* pMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE encode");
     mImpl->log("start vkCreateImageWithRequirementsGOOGLE");
     auto stream = mImpl->stream();
@@ -23205,9 +23707,9 @@ VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE(
     AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE returnUnmarshal");
     VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkCreateImageWithRequirementsGOOGLE_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateImageWithRequirementsGOOGLE");;
     return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
 }
@@ -23219,7 +23721,7 @@ VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE(
     VkBuffer* pBuffer,
     VkMemoryRequirements* pMemoryRequirements)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE encode");
     mImpl->log("start vkCreateBufferWithRequirementsGOOGLE");
     auto stream = mImpl->stream();
@@ -23306,9 +23808,9 @@ VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE(
     AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE returnUnmarshal");
     VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkCreateBufferWithRequirementsGOOGLE_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkCreateBufferWithRequirementsGOOGLE");;
     return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
 }
@@ -23322,7 +23824,7 @@ VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE(
     uint64_t* pSize,
     uint64_t* pHostmemId)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE encode");
     mImpl->log("start vkGetMemoryHostAddressInfoGOOGLE");
     auto stream = mImpl->stream();
@@ -23434,9 +23936,9 @@ VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE(
     AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE returnUnmarshal");
     VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryHostAddressInfoGOOGLE_VkResult_return, sizeof(VkResult));
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
     mImpl->log("finish vkGetMemoryHostAddressInfoGOOGLE");;
     return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
 }
@@ -23448,7 +23950,7 @@ VkResult VkEncoder::vkFreeMemorySyncGOOGLE(
     VkDeviceMemory memory,
     const VkAllocationCallbacks* pAllocator)
 {
-    AutoLock encoderLock(mImpl->lock);
+    EncoderAutoLock encoderLock(this);
     AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE encode");
     mImpl->log("start vkFreeMemorySyncGOOGLE");
     auto stream = mImpl->stream();
@@ -23507,14 +24009,249 @@ VkResult VkEncoder::vkFreeMemorySyncGOOGLE(
     AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE returnUnmarshal");
     VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkFreeMemorySyncGOOGLE_VkResult_return, sizeof(VkResult));
+    resources->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
+    pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
-    pool->freeAll();
-    resources->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
     mImpl->log("finish vkFreeMemorySyncGOOGLE");;
     return vkFreeMemorySyncGOOGLE_VkResult_return;
 }
 
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+void VkEncoder::vkQueueHostSyncGOOGLE(
+    VkQueue queue,
+    uint32_t needHostSync,
+    uint32_t sequenceNumber)
+{
+    EncoderAutoLock encoderLock(this);
+    AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE encode");
+    mImpl->log("start vkQueueHostSyncGOOGLE");
+    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_needHostSync;
+    uint32_t local_sequenceNumber;
+    local_queue = queue;
+    local_needHostSync = needHostSync;
+    local_sequenceNumber = sequenceNumber;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1553;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1553, 1);
+        countingStream->write((uint64_t*)&cgen_var_1553, 1 * 8);
+        countingStream->write((uint32_t*)&local_needHostSync, sizeof(uint32_t));
+        countingStream->write((uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
+    }
+    uint32_t packetSize_vkQueueHostSyncGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueHostSyncGOOGLE = OP_vkQueueHostSyncGOOGLE;
+    stream->write(&opcode_vkQueueHostSyncGOOGLE, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueHostSyncGOOGLE, sizeof(uint32_t));
+    uint64_t cgen_var_1554;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1554, 1);
+    stream->write((uint64_t*)&cgen_var_1554, 1 * 8);
+    stream->write((uint32_t*)&local_needHostSync, sizeof(uint32_t));
+    stream->write((uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
+    AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE readParams");
+    AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE returnUnmarshal");
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
+    mImpl->log("finish vkQueueHostSyncGOOGLE");;
+}
+
+void VkEncoder::vkQueueSubmitAsyncGOOGLE(
+    VkQueue queue,
+    uint32_t submitCount,
+    const VkSubmitInfo* pSubmits,
+    VkFence fence)
+{
+    EncoderAutoLock encoderLock(this);
+    AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE encode");
+    mImpl->log("start vkQueueSubmitAsyncGOOGLE");
+    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;
+    if (local_pSubmits)
+    {
+        for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
+        {
+            transform_tohost_VkSubmitInfo(mImpl->resources(), (VkSubmitInfo*)(local_pSubmits + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1555;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1555, 1);
+        countingStream->write((uint64_t*)&cgen_var_1555, 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_1556;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1556, 1);
+        countingStream->write((uint64_t*)&cgen_var_1556, 1 * 8);
+    }
+    uint32_t packetSize_vkQueueSubmitAsyncGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueSubmitAsyncGOOGLE = OP_vkQueueSubmitAsyncGOOGLE;
+    stream->write(&opcode_vkQueueSubmitAsyncGOOGLE, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueSubmitAsyncGOOGLE, sizeof(uint32_t));
+    uint64_t cgen_var_1557;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1557, 1);
+    stream->write((uint64_t*)&cgen_var_1557, 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_1558;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1558, 1);
+    stream->write((uint64_t*)&cgen_var_1558, 1 * 8);
+    AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE readParams");
+    AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE returnUnmarshal");
+    stream->flush();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
+    mImpl->log("finish vkQueueSubmitAsyncGOOGLE");;
+}
+
+void VkEncoder::vkQueueWaitIdleAsyncGOOGLE(
+    VkQueue queue)
+{
+    EncoderAutoLock encoderLock(this);
+    AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE encode");
+    mImpl->log("start vkQueueWaitIdleAsyncGOOGLE");
+    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_1559;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1559, 1);
+        countingStream->write((uint64_t*)&cgen_var_1559, 1 * 8);
+    }
+    uint32_t packetSize_vkQueueWaitIdleAsyncGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueWaitIdleAsyncGOOGLE = OP_vkQueueWaitIdleAsyncGOOGLE;
+    stream->write(&opcode_vkQueueWaitIdleAsyncGOOGLE, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueWaitIdleAsyncGOOGLE, sizeof(uint32_t));
+    uint64_t cgen_var_1560;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1560, 1);
+    stream->write((uint64_t*)&cgen_var_1560, 1 * 8);
+    AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE readParams");
+    AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE returnUnmarshal");
+    stream->flush();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
+    mImpl->log("finish vkQueueWaitIdleAsyncGOOGLE");;
+}
+
+void VkEncoder::vkQueueBindSparseAsyncGOOGLE(
+    VkQueue queue,
+    uint32_t bindInfoCount,
+    const VkBindSparseInfo* pBindInfo,
+    VkFence fence)
+{
+    EncoderAutoLock encoderLock(this);
+    AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE encode");
+    mImpl->log("start vkQueueBindSparseAsyncGOOGLE");
+    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;
+    if (local_pBindInfo)
+    {
+        for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+        {
+            transform_tohost_VkBindSparseInfo(mImpl->resources(), (VkBindSparseInfo*)(local_pBindInfo + i));
+        }
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1561;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1561, 1);
+        countingStream->write((uint64_t*)&cgen_var_1561, 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_1562;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1562, 1);
+        countingStream->write((uint64_t*)&cgen_var_1562, 1 * 8);
+    }
+    uint32_t packetSize_vkQueueBindSparseAsyncGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkQueueBindSparseAsyncGOOGLE = OP_vkQueueBindSparseAsyncGOOGLE;
+    stream->write(&opcode_vkQueueBindSparseAsyncGOOGLE, sizeof(uint32_t));
+    stream->write(&packetSize_vkQueueBindSparseAsyncGOOGLE, sizeof(uint32_t));
+    uint64_t cgen_var_1563;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1563, 1);
+    stream->write((uint64_t*)&cgen_var_1563, 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_1564;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1564, 1);
+    stream->write((uint64_t*)&cgen_var_1564, 1 * 8);
+    AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE readParams");
+    AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE returnUnmarshal");
+    stream->flush();
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
+    mImpl->log("finish vkQueueBindSparseAsyncGOOGLE");;
+}
+
+#endif
 
 } // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEncoder.h b/system/vulkan_enc/VkEncoder.h
index 8f49f7dc..bde9ab8a 100644
--- a/system/vulkan_enc/VkEncoder.h
+++ b/system/vulkan_enc/VkEncoder.h
@@ -28,7 +28,6 @@
 
 
 #include "goldfish_vk_private_defs.h"
-#include <functional>
 #include <memory>
 class IOStream;
 
@@ -42,10 +41,8 @@ public:
     ~VkEncoder();
 
     void flush();
-
-    using CleanupCallback = std::function<void()>;
-    void registerCleanupCallback(void* handle, CleanupCallback cb);
-    void unregisterCleanupCallback(void* handle);
+    void lock();
+    void unlock();
 #ifdef VK_VERSION_1_0
     VkResult vkCreateInstance(
     const VkInstanceCreateInfo* pCreateInfo,
@@ -1312,6 +1309,8 @@ public:
 #endif
 #ifdef VK_KHR_8bit_storage
 #endif
+#ifdef VK_KHR_shader_float16_int8
+#endif
 #ifdef VK_ANDROID_native_buffer
     VkResult vkGetSwapchainGrallocUsageANDROID(
     VkDevice device,
@@ -1821,6 +1820,24 @@ public:
         VkDeviceMemory memory,
         const VkAllocationCallbacks* pAllocator);
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+    void vkQueueHostSyncGOOGLE(
+    VkQueue queue,
+        uint32_t needHostSync,
+        uint32_t sequenceNumber);
+    void vkQueueSubmitAsyncGOOGLE(
+    VkQueue queue,
+        uint32_t submitCount,
+        const VkSubmitInfo* pSubmits,
+        VkFence fence);
+    void vkQueueWaitIdleAsyncGOOGLE(
+    VkQueue queue);
+    void vkQueueBindSparseAsyncGOOGLE(
+    VkQueue queue,
+        uint32_t bindInfoCount,
+        const VkBindSparseInfo* pBindInfo,
+        VkFence fence);
+#endif
 
 private:
     class Impl;
diff --git a/system/vulkan_enc/VulkanHandles.h b/system/vulkan_enc/VulkanHandles.h
index 54699aa1..ca1e5f2a 100644
--- a/system/vulkan_enc/VulkanHandles.h
+++ b/system/vulkan_enc/VulkanHandles.h
@@ -18,12 +18,12 @@
 
 #define GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
     f(VkPhysicalDevice) \
-    f(VkQueue) \
 
 #define GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(f) \
     f(VkInstance) \
     f(VkDevice) \
     f(VkCommandBuffer) \
+    f(VkQueue) \
     GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f)
 
 #ifdef VK_NVX_device_generated_commands
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
index 8e81c7fb..4f59d219 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -4412,6 +4412,24 @@ void deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR(
 }
 
 #endif
+#ifdef VK_KHR_shader_float16_int8
+void deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(
+    Pool* pool,
+    const VkPhysicalDeviceShaderFloat16Int8Features* from,
+    VkPhysicalDeviceShaderFloat16Int8Features* 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,
@@ -6406,6 +6424,8 @@ void deepcopy_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_free_memory_sync
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#endif
 void deepcopy_extension_struct(
     Pool* pool,
     const void* structExtension,
@@ -6724,6 +6744,13 @@ void deepcopy_extension_struct(
             break;
         }
 #endif
+#ifdef VK_KHR_shader_float16_int8
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        {
+            deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(pool, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
         {
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
index c0fdfcb7..243240a4 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -1356,6 +1356,13 @@ void deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR(
     VkPhysicalDevice8BitStorageFeaturesKHR* to);
 
 #endif
+#ifdef VK_KHR_shader_float16_int8
+void deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(
+    Pool* pool,
+    const VkPhysicalDeviceShaderFloat16Int8Features* from,
+    VkPhysicalDeviceShaderFloat16Int8Features* to);
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void deepcopy_VkNativeBufferANDROID(
     Pool* pool,
@@ -2037,5 +2044,7 @@ void deepcopy_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_free_memory_sync
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#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
index 2f50b397..1bc69fa1 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -132,6 +132,8 @@ namespace goldfish_vk {
 #endif
 #ifdef VK_KHR_8bit_storage
 #endif
+#ifdef VK_KHR_shader_float16_int8
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_debug_report
@@ -288,6 +290,8 @@ namespace goldfish_vk {
 #endif
 #ifdef VK_GOOGLE_free_memory_sync
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#endif
 uint32_t goldfish_vk_struct_type(
     const void* structExtension)
 {
@@ -555,6 +559,581 @@ size_t goldfish_vk_extension_struct_size(
             return sizeof(VkPhysicalDevice8BitStorageFeaturesKHR);
         }
 #endif
+#ifdef VK_KHR_shader_float16_int8
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        {
+            return sizeof(VkPhysicalDeviceShaderFloat16Int8Features);
+        }
+#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
+#ifdef VK_GOOGLE_color_buffer
+        case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+        {
+            return sizeof(VkImportColorBufferGOOGLE);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+        {
+            return sizeof(VkImportBufferGOOGLE);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+        {
+            return sizeof(VkImportPhysicalAddressGOOGLE);
+        }
+#endif
+        default:
+        {
+            return (size_t)0;
+        }
+    }
+}
+
+size_t goldfish_vk_extension_struct_size_with_stream_features(
+    uint32_t streamFeatures,
+    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_KHR_shader_float16_int8
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        {
+            if (streamFeatures & VULKAN_STREAM_FEATURE_SHADER_FLOAT16_INT8_BIT)
+            {
+                return sizeof(VkPhysicalDeviceShaderFloat16Int8Features);
+            }
+            else
+            {
+                return 0;
+            }
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
         {
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
index 5a3fc66a..9d91cdc4 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
@@ -45,6 +45,10 @@ uint32_t goldfish_vk_struct_type(
 size_t goldfish_vk_extension_struct_size(
     const void* structExtension);
 
+size_t goldfish_vk_extension_struct_size_with_stream_features(
+    uint32_t streamFeatures,
+    const void* structExtension);
+
 #ifdef VK_VERSION_1_0
 #endif
 #ifdef VK_VERSION_1_1
@@ -149,6 +153,8 @@ size_t goldfish_vk_extension_struct_size(
 #endif
 #ifdef VK_KHR_8bit_storage
 #endif
+#ifdef VK_KHR_shader_float16_int8
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_debug_report
@@ -305,5 +311,7 @@ size_t goldfish_vk_extension_struct_size(
 #endif
 #ifdef VK_GOOGLE_free_memory_sync
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#endif
 
 } // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
index 976e1241..2e22fb0c 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
@@ -3300,6 +3300,20 @@ void handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(
 }
 
 #endif
+#ifdef VK_KHR_shader_float16_int8
+void handlemap_VkPhysicalDeviceShaderFloat16Int8Features(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceShaderFloat16Int8Features* 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,
@@ -4766,6 +4780,8 @@ void handlemap_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_free_memory_sync
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#endif
 void handlemap_extension_struct(
     VulkanHandleMapping* handlemap,
     void* structExtension_out)
@@ -5083,6 +5099,13 @@ void handlemap_extension_struct(
             break;
         }
 #endif
+#ifdef VK_KHR_shader_float16_int8
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        {
+            handlemap_VkPhysicalDeviceShaderFloat16Int8Features(handlemap, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
         {
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.h b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
index 071c2185..79eeaf66 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.h
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
@@ -1113,6 +1113,12 @@ void handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(
     VkPhysicalDevice8BitStorageFeaturesKHR* toMap);
 
 #endif
+#ifdef VK_KHR_shader_float16_int8
+void handlemap_VkPhysicalDeviceShaderFloat16Int8Features(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceShaderFloat16Int8Features* toMap);
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void handlemap_VkNativeBufferANDROID(
     VulkanHandleMapping* handlemap,
@@ -1689,5 +1695,7 @@ void handlemap_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_free_memory_sync
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#endif
 
 } // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index 94745725..f857a2a8 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -45,13 +45,7 @@ void marshal_VkApplicationInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
     {
         // WARNING PTR CHECK
@@ -90,14 +84,7 @@ void unmarshal_VkApplicationInfo(
     VkApplicationInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
     {
         // WARNING PTR CHECK
@@ -144,13 +131,7 @@ void marshal_VkInstanceCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkInstanceCreateFlags*)&forMarshaling->flags, sizeof(VkInstanceCreateFlags));
     // WARNING PTR CHECK
     uint64_t cgen_var_4 = (uint64_t)(uintptr_t)forMarshaling->pApplicationInfo;
@@ -170,14 +151,7 @@ void unmarshal_VkInstanceCreateInfo(
     VkInstanceCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkInstanceCreateFlags*)&forUnmarshaling->flags, sizeof(VkInstanceCreateFlags));
     // WARNING PTR CHECK
     const VkApplicationInfo* check_pApplicationInfo;
@@ -787,13 +761,7 @@ void marshal_VkDeviceQueueCreateInfo(
     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);
-    }
+    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));
@@ -805,14 +773,7 @@ void unmarshal_VkDeviceQueueCreateInfo(
     VkDeviceQueueCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -824,13 +785,7 @@ void marshal_VkDeviceCreateInfo(
     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);
-    }
+    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)
@@ -855,14 +810,7 @@ void unmarshal_VkDeviceCreateInfo(
     VkDeviceCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDeviceCreateFlags*)&forUnmarshaling->flags, sizeof(VkDeviceCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->queueCreateInfoCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueCreateInfoCount; ++i)
@@ -927,13 +875,7 @@ void marshal_VkSubmitInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
     if (forMarshaling->waitSemaphoreCount)
     {
@@ -966,14 +908,7 @@ void unmarshal_VkSubmitInfo(
     VkSubmitInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
     if (forUnmarshaling->waitSemaphoreCount)
     {
@@ -1006,13 +941,7 @@ void marshal_VkMemoryAllocateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
     vkStream->write((uint32_t*)&forMarshaling->memoryTypeIndex, sizeof(uint32_t));
 }
@@ -1022,14 +951,7 @@ void unmarshal_VkMemoryAllocateInfo(
     VkMemoryAllocateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDeviceSize*)&forUnmarshaling->allocationSize, sizeof(VkDeviceSize));
     vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeIndex, sizeof(uint32_t));
 }
@@ -1039,13 +961,7 @@ void marshal_VkMappedMemoryRange(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_28;
     vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_28, 1);
     vkStream->write((uint64_t*)&cgen_var_28, 1 * 8);
@@ -1058,14 +974,7 @@ void unmarshal_VkMappedMemoryRange(
     VkMappedMemoryRange* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_29;
     vkStream->read((uint64_t*)&cgen_var_29, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_29, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
@@ -1310,13 +1219,7 @@ void marshal_VkBindSparseInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
     if (forMarshaling->waitSemaphoreCount)
     {
@@ -1355,14 +1258,7 @@ void unmarshal_VkBindSparseInfo(
     VkBindSparseInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
     if (forUnmarshaling->waitSemaphoreCount)
     {
@@ -1401,13 +1297,7 @@ void marshal_VkFenceCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkFenceCreateFlags*)&forMarshaling->flags, sizeof(VkFenceCreateFlags));
 }
 
@@ -1416,14 +1306,7 @@ void unmarshal_VkFenceCreateInfo(
     VkFenceCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkFenceCreateFlags*)&forUnmarshaling->flags, sizeof(VkFenceCreateFlags));
 }
 
@@ -1432,13 +1315,7 @@ void marshal_VkSemaphoreCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkSemaphoreCreateFlags*)&forMarshaling->flags, sizeof(VkSemaphoreCreateFlags));
 }
 
@@ -1447,14 +1324,7 @@ void unmarshal_VkSemaphoreCreateInfo(
     VkSemaphoreCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkSemaphoreCreateFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreCreateFlags));
 }
 
@@ -1463,13 +1333,7 @@ void marshal_VkEventCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkEventCreateFlags*)&forMarshaling->flags, sizeof(VkEventCreateFlags));
 }
 
@@ -1478,14 +1342,7 @@ void unmarshal_VkEventCreateInfo(
     VkEventCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkEventCreateFlags*)&forUnmarshaling->flags, sizeof(VkEventCreateFlags));
 }
 
@@ -1494,13 +1351,7 @@ void marshal_VkQueryPoolCreateInfo(
     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);
-    }
+    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));
@@ -1512,14 +1363,7 @@ void unmarshal_VkQueryPoolCreateInfo(
     VkQueryPoolCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -1531,13 +1375,7 @@ void marshal_VkBufferCreateInfo(
     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);
-    }
+    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));
@@ -1557,14 +1395,7 @@ void unmarshal_VkBufferCreateInfo(
     VkBufferCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -1588,13 +1419,7 @@ void marshal_VkBufferViewCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBufferViewCreateFlags*)&forMarshaling->flags, sizeof(VkBufferViewCreateFlags));
     uint64_t cgen_var_46;
     vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_46, 1);
@@ -1609,14 +1434,7 @@ void unmarshal_VkBufferViewCreateInfo(
     VkBufferViewCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBufferViewCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferViewCreateFlags));
     uint64_t cgen_var_47;
     vkStream->read((uint64_t*)&cgen_var_47, 1 * 8);
@@ -1631,13 +1449,7 @@ void marshal_VkImageCreateInfo(
     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);
-    }
+    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));
@@ -1664,14 +1476,7 @@ void unmarshal_VkImageCreateInfo(
     VkImageCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -1766,13 +1571,7 @@ void marshal_VkImageViewCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkImageViewCreateFlags*)&forMarshaling->flags, sizeof(VkImageViewCreateFlags));
     uint64_t cgen_var_50;
     vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_50, 1);
@@ -1788,14 +1587,7 @@ void unmarshal_VkImageViewCreateInfo(
     VkImageViewCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkImageViewCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageViewCreateFlags));
     uint64_t cgen_var_51;
     vkStream->read((uint64_t*)&cgen_var_51, 1 * 8);
@@ -1811,13 +1603,7 @@ void marshal_VkShaderModuleCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkShaderModuleCreateFlags*)&forMarshaling->flags, sizeof(VkShaderModuleCreateFlags));
     uint64_t cgen_var_52 = (uint64_t)forMarshaling->codeSize;
     vkStream->putBe64(cgen_var_52);
@@ -1829,14 +1615,7 @@ void unmarshal_VkShaderModuleCreateInfo(
     VkShaderModuleCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkShaderModuleCreateFlags*)&forUnmarshaling->flags, sizeof(VkShaderModuleCreateFlags));
     forUnmarshaling->codeSize = (size_t)vkStream->getBe64();
     vkStream->read((uint32_t*)forUnmarshaling->pCode, (forUnmarshaling->codeSize / 4) * sizeof(const uint32_t));
@@ -1847,13 +1626,7 @@ void marshal_VkPipelineCacheCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkPipelineCacheCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
     uint64_t cgen_var_54 = (uint64_t)forMarshaling->initialDataSize;
     vkStream->putBe64(cgen_var_54);
@@ -1865,14 +1638,7 @@ void unmarshal_VkPipelineCacheCreateInfo(
     VkPipelineCacheCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkPipelineCacheCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
     forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
     vkStream->read((void*)forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
@@ -1929,13 +1695,7 @@ void marshal_VkPipelineShaderStageCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkPipelineShaderStageCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineShaderStageCreateFlags));
     vkStream->write((VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
     uint64_t cgen_var_60;
@@ -1956,14 +1716,7 @@ void unmarshal_VkPipelineShaderStageCreateInfo(
     VkPipelineShaderStageCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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_62;
@@ -2026,13 +1779,7 @@ void marshal_VkPipelineVertexInputStateCreateInfo(
     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);
-    }
+    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)
@@ -2051,14 +1798,7 @@ void unmarshal_VkPipelineVertexInputStateCreateInfo(
     VkPipelineVertexInputStateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkPipelineVertexInputStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineVertexInputStateCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDescriptionCount; ++i)
@@ -2077,13 +1817,7 @@ void marshal_VkPipelineInputAssemblyStateCreateInfo(
     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);
-    }
+    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));
@@ -2094,14 +1828,7 @@ void unmarshal_VkPipelineInputAssemblyStateCreateInfo(
     VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -2112,13 +1839,7 @@ void marshal_VkPipelineTessellationStateCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkPipelineTessellationStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineTessellationStateCreateFlags));
     vkStream->write((uint32_t*)&forMarshaling->patchControlPoints, sizeof(uint32_t));
 }
@@ -2128,14 +1849,7 @@ void unmarshal_VkPipelineTessellationStateCreateInfo(
     VkPipelineTessellationStateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkPipelineTessellationStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineTessellationStateCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->patchControlPoints, sizeof(uint32_t));
 }
@@ -2217,13 +1931,7 @@ void marshal_VkPipelineViewportStateCreateInfo(
     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);
-    }
+    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
@@ -2254,14 +1962,7 @@ void unmarshal_VkPipelineViewportStateCreateInfo(
     VkPipelineViewportStateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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
@@ -2300,13 +2001,7 @@ void marshal_VkPipelineRasterizationStateCreateInfo(
     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);
-    }
+    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));
@@ -2325,14 +2020,7 @@ void unmarshal_VkPipelineRasterizationStateCreateInfo(
     VkPipelineRasterizationStateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -2351,13 +2039,7 @@ void marshal_VkPipelineMultisampleStateCreateInfo(
     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);
-    }
+    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));
@@ -2378,14 +2060,7 @@ void unmarshal_VkPipelineMultisampleStateCreateInfo(
     VkPipelineMultisampleStateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -2436,13 +2111,7 @@ void marshal_VkPipelineDepthStencilStateCreateInfo(
     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);
-    }
+    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));
@@ -2460,14 +2129,7 @@ void unmarshal_VkPipelineDepthStencilStateCreateInfo(
     VkPipelineDepthStencilStateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -2513,13 +2175,7 @@ void marshal_VkPipelineColorBlendStateCreateInfo(
     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);
-    }
+    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));
@@ -2536,14 +2192,7 @@ void unmarshal_VkPipelineColorBlendStateCreateInfo(
     VkPipelineColorBlendStateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -2560,13 +2209,7 @@ void marshal_VkPipelineDynamicStateCreateInfo(
     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);
-    }
+    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));
@@ -2577,14 +2220,7 @@ void unmarshal_VkPipelineDynamicStateCreateInfo(
     VkPipelineDynamicStateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkPipelineDynamicStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineDynamicStateCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->dynamicStateCount, sizeof(uint32_t));
     vkStream->read((VkDynamicState*)forUnmarshaling->pDynamicStates, forUnmarshaling->dynamicStateCount * sizeof(const VkDynamicState));
@@ -2609,13 +2245,7 @@ void marshal_VkGraphicsPipelineCreateInfo(
         vkStream->putBe32(cgen_var_71);
     }
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
-    vkStream->putBe32(pNext_size);
-    if (pNext_size)
-    {
-        vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
-        marshal_extension_struct(vkStream, forMarshaling->pNext);
-    }
+    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)
@@ -2737,14 +2367,7 @@ void unmarshal_VkGraphicsPipelineCreateInfo(
         hasTessellation = (const uint32_t)vkStream->getBe32();
     }
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i)
@@ -2900,13 +2523,7 @@ void marshal_VkComputePipelineCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
     marshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage));
     uint64_t cgen_var_98;
@@ -2923,14 +2540,7 @@ void unmarshal_VkComputePipelineCreateInfo(
     VkComputePipelineCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
     unmarshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forUnmarshaling->stage));
     uint64_t cgen_var_100;
@@ -2965,13 +2575,7 @@ void marshal_VkPipelineLayoutCreateInfo(
     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);
-    }
+    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)
@@ -2993,14 +2597,7 @@ void unmarshal_VkPipelineLayoutCreateInfo(
     VkPipelineLayoutCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkPipelineLayoutCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineLayoutCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
     if (forUnmarshaling->setLayoutCount)
@@ -3022,13 +2619,7 @@ void marshal_VkSamplerCreateInfo(
     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);
-    }
+    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));
@@ -3052,14 +2643,7 @@ void unmarshal_VkSamplerCreateInfo(
     VkSamplerCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -3133,13 +2717,7 @@ void marshal_VkDescriptorSetLayoutCreateInfo(
     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);
-    }
+    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)
@@ -3153,14 +2731,7 @@ void unmarshal_VkDescriptorSetLayoutCreateInfo(
     VkDescriptorSetLayoutCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDescriptorSetLayoutCreateFlags*)&forUnmarshaling->flags, sizeof(VkDescriptorSetLayoutCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindingCount; ++i)
@@ -3190,13 +2761,7 @@ void marshal_VkDescriptorPoolCreateInfo(
     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);
-    }
+    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));
@@ -3211,14 +2776,7 @@ void unmarshal_VkDescriptorPoolCreateInfo(
     VkDescriptorPoolCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -3233,13 +2791,7 @@ void marshal_VkDescriptorSetAllocateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_108;
     vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool, &cgen_var_108, 1);
     vkStream->write((uint64_t*)&cgen_var_108, 1 * 8);
@@ -3258,14 +2810,7 @@ void unmarshal_VkDescriptorSetAllocateInfo(
     VkDescriptorSetAllocateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_110;
     vkStream->read((uint64_t*)&cgen_var_110, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_110, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
@@ -3332,13 +2877,7 @@ void marshal_VkWriteDescriptorSet(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_118;
     vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_118, 1);
     vkStream->write((uint64_t*)&cgen_var_118, 1 * 8);
@@ -3395,14 +2934,7 @@ void unmarshal_VkWriteDescriptorSet(
     VkWriteDescriptorSet* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_123;
     vkStream->read((uint64_t*)&cgen_var_123, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_123, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
@@ -3483,13 +3015,7 @@ void marshal_VkCopyDescriptorSet(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_128;
     vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_128, 1);
     vkStream->write((uint64_t*)&cgen_var_128, 1 * 8);
@@ -3508,14 +3034,7 @@ void unmarshal_VkCopyDescriptorSet(
     VkCopyDescriptorSet* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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_VkDescriptorSet(&cgen_var_130, (VkDescriptorSet*)&forUnmarshaling->srcSet, 1);
@@ -3534,13 +3053,7 @@ void marshal_VkFramebufferCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkFramebufferCreateFlags*)&forMarshaling->flags, sizeof(VkFramebufferCreateFlags));
     uint64_t cgen_var_132;
     vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_132, 1);
@@ -3563,14 +3076,7 @@ void unmarshal_VkFramebufferCreateInfo(
     VkFramebufferCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkFramebufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkFramebufferCreateFlags));
     uint64_t cgen_var_134;
     vkStream->read((uint64_t*)&cgen_var_134, 1 * 8);
@@ -3747,13 +3253,7 @@ void marshal_VkRenderPassCreateInfo(
     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);
-    }
+    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)
@@ -3777,14 +3277,7 @@ void unmarshal_VkRenderPassCreateInfo(
     VkRenderPassCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags, sizeof(VkRenderPassCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
@@ -3808,13 +3301,7 @@ void marshal_VkCommandPoolCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkCommandPoolCreateFlags*)&forMarshaling->flags, sizeof(VkCommandPoolCreateFlags));
     vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
 }
@@ -3824,14 +3311,7 @@ void unmarshal_VkCommandPoolCreateInfo(
     VkCommandPoolCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkCommandPoolCreateFlags*)&forUnmarshaling->flags, sizeof(VkCommandPoolCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
 }
@@ -3841,13 +3321,7 @@ void marshal_VkCommandBufferAllocateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_140;
     vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool, &cgen_var_140, 1);
     vkStream->write((uint64_t*)&cgen_var_140, 1 * 8);
@@ -3860,14 +3334,7 @@ void unmarshal_VkCommandBufferAllocateInfo(
     VkCommandBufferAllocateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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_VkCommandPool(&cgen_var_141, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
@@ -3880,13 +3347,7 @@ void marshal_VkCommandBufferInheritanceInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_142;
     vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_142, 1);
     vkStream->write((uint64_t*)&cgen_var_142, 1 * 8);
@@ -3904,14 +3365,7 @@ void unmarshal_VkCommandBufferInheritanceInfo(
     VkCommandBufferInheritanceInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_144;
     vkStream->read((uint64_t*)&cgen_var_144, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_144, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
@@ -3929,13 +3383,7 @@ void marshal_VkCommandBufferBeginInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkCommandBufferUsageFlags*)&forMarshaling->flags, sizeof(VkCommandBufferUsageFlags));
     // WARNING PTR CHECK
     uint64_t cgen_var_146 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
@@ -3951,14 +3399,7 @@ void unmarshal_VkCommandBufferBeginInfo(
     VkCommandBufferBeginInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkCommandBufferUsageFlags*)&forUnmarshaling->flags, sizeof(VkCommandBufferUsageFlags));
     // WARNING PTR CHECK
     const VkCommandBufferInheritanceInfo* check_pInheritanceInfo;
@@ -4196,13 +3637,7 @@ void marshal_VkMemoryBarrier(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
     vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
 }
@@ -4212,14 +3647,7 @@ void unmarshal_VkMemoryBarrier(
     VkMemoryBarrier* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
     vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
 }
@@ -4229,13 +3657,7 @@ void marshal_VkBufferMemoryBarrier(
     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);
-    }
+    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));
@@ -4252,14 +3674,7 @@ void unmarshal_VkBufferMemoryBarrier(
     VkBufferMemoryBarrier* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -4276,13 +3691,7 @@ void marshal_VkImageMemoryBarrier(
     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);
-    }
+    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));
@@ -4300,14 +3709,7 @@ void unmarshal_VkImageMemoryBarrier(
     VkImageMemoryBarrier* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -4325,13 +3727,7 @@ void marshal_VkRenderPassBeginInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_152;
     vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_152, 1);
     vkStream->write((uint64_t*)&cgen_var_152, 1 * 8);
@@ -4357,14 +3753,7 @@ void unmarshal_VkRenderPassBeginInfo(
     VkRenderPassBeginInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_155;
     vkStream->read((uint64_t*)&cgen_var_155, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_155, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
@@ -4454,13 +3843,7 @@ void marshal_VkBaseOutStructure(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
 }
 
 void unmarshal_VkBaseOutStructure(
@@ -4468,14 +3851,7 @@ void unmarshal_VkBaseOutStructure(
     VkBaseOutStructure* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((VkBaseOutStructure*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
 }
 
 void marshal_VkBaseInStructure(
@@ -4483,13 +3859,7 @@ void marshal_VkBaseInStructure(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
 }
 
 void unmarshal_VkBaseInStructure(
@@ -4497,14 +3867,7 @@ void unmarshal_VkBaseInStructure(
     VkBaseInStructure* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((VkBaseInStructure*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
 }
 
 #endif
@@ -4514,13 +3877,7 @@ void marshal_VkPhysicalDeviceSubgroupProperties(
     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);
-    }
+    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));
@@ -4532,14 +3889,7 @@ void unmarshal_VkPhysicalDeviceSubgroupProperties(
     VkPhysicalDeviceSubgroupProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -4551,13 +3901,7 @@ void marshal_VkBindBufferMemoryInfo(
     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);
-    }
+    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);
@@ -4572,14 +3916,7 @@ void unmarshal_VkBindBufferMemoryInfo(
     VkBindBufferMemoryInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_160;
     vkStream->read((uint64_t*)&cgen_var_160, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_160, (VkBuffer*)&forUnmarshaling->buffer, 1);
@@ -4594,13 +3931,7 @@ void marshal_VkBindImageMemoryInfo(
     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);
-    }
+    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);
@@ -4615,14 +3946,7 @@ void unmarshal_VkBindImageMemoryInfo(
     VkBindImageMemoryInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_164;
     vkStream->read((uint64_t*)&cgen_var_164, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_164, (VkImage*)&forUnmarshaling->image, 1);
@@ -4637,13 +3961,7 @@ void marshal_VkPhysicalDevice16BitStorageFeatures(
     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);
-    }
+    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));
@@ -4655,14 +3973,7 @@ void unmarshal_VkPhysicalDevice16BitStorageFeatures(
     VkPhysicalDevice16BitStorageFeatures* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -4674,13 +3985,7 @@ void marshal_VkMemoryDedicatedRequirements(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
     vkStream->write((VkBool32*)&forMarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
 }
@@ -4690,14 +3995,7 @@ void unmarshal_VkMemoryDedicatedRequirements(
     VkMemoryDedicatedRequirements* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
     vkStream->read((VkBool32*)&forUnmarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
 }
@@ -4707,13 +4005,7 @@ void marshal_VkMemoryDedicatedAllocateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_166;
     vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_166, 1);
     vkStream->write((uint64_t*)&cgen_var_166, 1 * 8);
@@ -4727,14 +4019,7 @@ void unmarshal_VkMemoryDedicatedAllocateInfo(
     VkMemoryDedicatedAllocateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_168;
     vkStream->read((uint64_t*)&cgen_var_168, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_168, (VkImage*)&forUnmarshaling->image, 1);
@@ -4748,13 +4033,7 @@ void marshal_VkMemoryAllocateFlagsInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkMemoryAllocateFlags*)&forMarshaling->flags, sizeof(VkMemoryAllocateFlags));
     vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
 }
@@ -4764,14 +4043,7 @@ void unmarshal_VkMemoryAllocateFlagsInfo(
     VkMemoryAllocateFlagsInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkMemoryAllocateFlags*)&forUnmarshaling->flags, sizeof(VkMemoryAllocateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
 }
@@ -4781,13 +4053,7 @@ void marshal_VkDeviceGroupRenderPassBeginInfo(
     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);
-    }
+    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)
@@ -4801,14 +4067,7 @@ void unmarshal_VkDeviceGroupRenderPassBeginInfo(
     VkDeviceGroupRenderPassBeginInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->deviceRenderAreaCount; ++i)
@@ -4822,13 +4081,7 @@ void marshal_VkDeviceGroupCommandBufferBeginInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
 }
 
@@ -4837,14 +4090,7 @@ void unmarshal_VkDeviceGroupCommandBufferBeginInfo(
     VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
 }
 
@@ -4853,13 +4099,7 @@ void marshal_VkDeviceGroupSubmitInfo(
     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);
-    }
+    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));
@@ -4873,14 +4113,7 @@ void unmarshal_VkDeviceGroupSubmitInfo(
     VkDeviceGroupSubmitInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
     vkStream->read((uint32_t*)forUnmarshaling->pWaitSemaphoreDeviceIndices, forUnmarshaling->waitSemaphoreCount * sizeof(const uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
@@ -4894,13 +4127,7 @@ void marshal_VkDeviceGroupBindSparseInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->resourceDeviceIndex, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->memoryDeviceIndex, sizeof(uint32_t));
 }
@@ -4910,14 +4137,7 @@ void unmarshal_VkDeviceGroupBindSparseInfo(
     VkDeviceGroupBindSparseInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
 }
@@ -4927,13 +4147,7 @@ void marshal_VkBindBufferMemoryDeviceGroupInfo(
     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);
-    }
+    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));
 }
@@ -4943,14 +4157,7 @@ void unmarshal_VkBindBufferMemoryDeviceGroupInfo(
     VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
     vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
 }
@@ -4960,13 +4167,7 @@ void marshal_VkBindImageMemoryDeviceGroupInfo(
     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);
-    }
+    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));
@@ -4981,14 +4182,7 @@ void unmarshal_VkBindImageMemoryDeviceGroupInfo(
     VkBindImageMemoryDeviceGroupInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
     vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
@@ -5003,13 +4197,7 @@ void marshal_VkPhysicalDeviceGroupProperties(
     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);
-    }
+    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));
@@ -5020,14 +4208,7 @@ void unmarshal_VkPhysicalDeviceGroupProperties(
     VkPhysicalDeviceGroupProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -5038,13 +4219,7 @@ void marshal_VkDeviceGroupDeviceCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
     if (forMarshaling->physicalDeviceCount)
     {
@@ -5060,14 +4235,7 @@ void unmarshal_VkDeviceGroupDeviceCreateInfo(
     VkDeviceGroupDeviceCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
     if (forUnmarshaling->physicalDeviceCount)
     {
@@ -5083,13 +4251,7 @@ void marshal_VkBufferMemoryRequirementsInfo2(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_172;
     vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_172, 1);
     vkStream->write((uint64_t*)&cgen_var_172, 1 * 8);
@@ -5100,14 +4262,7 @@ void unmarshal_VkBufferMemoryRequirementsInfo2(
     VkBufferMemoryRequirementsInfo2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_173;
     vkStream->read((uint64_t*)&cgen_var_173, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_173, (VkBuffer*)&forUnmarshaling->buffer, 1);
@@ -5118,13 +4273,7 @@ void marshal_VkImageMemoryRequirementsInfo2(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_174;
     vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_174, 1);
     vkStream->write((uint64_t*)&cgen_var_174, 1 * 8);
@@ -5135,14 +4284,7 @@ void unmarshal_VkImageMemoryRequirementsInfo2(
     VkImageMemoryRequirementsInfo2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_175;
     vkStream->read((uint64_t*)&cgen_var_175, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_175, (VkImage*)&forUnmarshaling->image, 1);
@@ -5153,13 +4295,7 @@ void marshal_VkImageSparseMemoryRequirementsInfo2(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_176;
     vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_176, 1);
     vkStream->write((uint64_t*)&cgen_var_176, 1 * 8);
@@ -5170,14 +4306,7 @@ void unmarshal_VkImageSparseMemoryRequirementsInfo2(
     VkImageSparseMemoryRequirementsInfo2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_177;
     vkStream->read((uint64_t*)&cgen_var_177, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_177, (VkImage*)&forUnmarshaling->image, 1);
@@ -5188,13 +4317,7 @@ void marshal_VkMemoryRequirements2(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkMemoryRequirements(vkStream, (VkMemoryRequirements*)(&forMarshaling->memoryRequirements));
 }
 
@@ -5203,14 +4326,7 @@ void unmarshal_VkMemoryRequirements2(
     VkMemoryRequirements2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkMemoryRequirements(vkStream, (VkMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
 }
 
@@ -5219,13 +4335,7 @@ void marshal_VkSparseImageMemoryRequirements2(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkSparseImageMemoryRequirements(vkStream, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements));
 }
 
@@ -5234,14 +4344,7 @@ void unmarshal_VkSparseImageMemoryRequirements2(
     VkSparseImageMemoryRequirements2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkSparseImageMemoryRequirements(vkStream, (VkSparseImageMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
 }
 
@@ -5250,13 +4353,7 @@ void marshal_VkPhysicalDeviceFeatures2(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(&forMarshaling->features));
 }
 
@@ -5265,14 +4362,7 @@ void unmarshal_VkPhysicalDeviceFeatures2(
     VkPhysicalDeviceFeatures2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(&forUnmarshaling->features));
 }
 
@@ -5281,13 +4371,7 @@ void marshal_VkPhysicalDeviceProperties2(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkPhysicalDeviceProperties(vkStream, (VkPhysicalDeviceProperties*)(&forMarshaling->properties));
 }
 
@@ -5296,14 +4380,7 @@ void unmarshal_VkPhysicalDeviceProperties2(
     VkPhysicalDeviceProperties2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkPhysicalDeviceProperties(vkStream, (VkPhysicalDeviceProperties*)(&forUnmarshaling->properties));
 }
 
@@ -5312,13 +4389,7 @@ void marshal_VkFormatProperties2(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkFormatProperties(vkStream, (VkFormatProperties*)(&forMarshaling->formatProperties));
 }
 
@@ -5327,14 +4398,7 @@ void unmarshal_VkFormatProperties2(
     VkFormatProperties2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkFormatProperties(vkStream, (VkFormatProperties*)(&forUnmarshaling->formatProperties));
 }
 
@@ -5343,13 +4407,7 @@ void marshal_VkImageFormatProperties2(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
 }
 
@@ -5358,14 +4416,7 @@ void unmarshal_VkImageFormatProperties2(
     VkImageFormatProperties2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
 }
 
@@ -5374,13 +4425,7 @@ void marshal_VkPhysicalDeviceImageFormatInfo2(
     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);
-    }
+    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));
@@ -5393,14 +4438,7 @@ void unmarshal_VkPhysicalDeviceImageFormatInfo2(
     VkPhysicalDeviceImageFormatInfo2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -5413,13 +4451,7 @@ void marshal_VkQueueFamilyProperties2(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkQueueFamilyProperties(vkStream, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties));
 }
 
@@ -5428,14 +4460,7 @@ void unmarshal_VkQueueFamilyProperties2(
     VkQueueFamilyProperties2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkQueueFamilyProperties(vkStream, (VkQueueFamilyProperties*)(&forUnmarshaling->queueFamilyProperties));
 }
 
@@ -5444,13 +4469,7 @@ void marshal_VkPhysicalDeviceMemoryProperties2(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkPhysicalDeviceMemoryProperties(vkStream, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties));
 }
 
@@ -5459,14 +4478,7 @@ void unmarshal_VkPhysicalDeviceMemoryProperties2(
     VkPhysicalDeviceMemoryProperties2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkPhysicalDeviceMemoryProperties(vkStream, (VkPhysicalDeviceMemoryProperties*)(&forUnmarshaling->memoryProperties));
 }
 
@@ -5475,13 +4487,7 @@ void marshal_VkSparseImageFormatProperties2(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forMarshaling->properties));
 }
 
@@ -5490,14 +4496,7 @@ void unmarshal_VkSparseImageFormatProperties2(
     VkSparseImageFormatProperties2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forUnmarshaling->properties));
 }
 
@@ -5506,13 +4505,7 @@ void marshal_VkPhysicalDeviceSparseImageFormatInfo2(
     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);
-    }
+    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));
@@ -5525,14 +4518,7 @@ void unmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
     VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -5545,13 +4531,7 @@ void marshal_VkPhysicalDevicePointClippingProperties(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
 }
 
@@ -5560,14 +4540,7 @@ void unmarshal_VkPhysicalDevicePointClippingProperties(
     VkPhysicalDevicePointClippingProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkPointClippingBehavior*)&forUnmarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
 }
 
@@ -5594,13 +4567,7 @@ void marshal_VkRenderPassInputAttachmentAspectCreateInfo(
     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);
-    }
+    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)
     {
@@ -5613,14 +4580,7 @@ void unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
     VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->aspectReferenceCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->aspectReferenceCount; ++i)
     {
@@ -5633,13 +4593,7 @@ void marshal_VkImageViewUsageCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
 }
 
@@ -5648,14 +4602,7 @@ void unmarshal_VkImageViewUsageCreateInfo(
     VkImageViewUsageCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
 }
 
@@ -5664,13 +4611,7 @@ void marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkTessellationDomainOrigin*)&forMarshaling->domainOrigin, sizeof(VkTessellationDomainOrigin));
 }
 
@@ -5679,14 +4620,7 @@ void unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
     VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkTessellationDomainOrigin*)&forUnmarshaling->domainOrigin, sizeof(VkTessellationDomainOrigin));
 }
 
@@ -5695,13 +4629,7 @@ void marshal_VkRenderPassMultiviewCreateInfo(
     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);
-    }
+    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));
@@ -5715,14 +4643,7 @@ void unmarshal_VkRenderPassMultiviewCreateInfo(
     VkRenderPassMultiviewCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
     vkStream->read((uint32_t*)forUnmarshaling->pViewMasks, forUnmarshaling->subpassCount * sizeof(const uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
@@ -5736,13 +4657,7 @@ void marshal_VkPhysicalDeviceMultiviewFeatures(
     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);
-    }
+    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));
@@ -5753,14 +4668,7 @@ void unmarshal_VkPhysicalDeviceMultiviewFeatures(
     VkPhysicalDeviceMultiviewFeatures* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -5771,13 +4679,7 @@ void marshal_VkPhysicalDeviceMultiviewProperties(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->maxMultiviewViewCount, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
 }
@@ -5787,14 +4689,7 @@ void unmarshal_VkPhysicalDeviceMultiviewProperties(
     VkPhysicalDeviceMultiviewProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
 }
@@ -5804,13 +4699,7 @@ void marshal_VkPhysicalDeviceVariablePointerFeatures(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
     vkStream->write((VkBool32*)&forMarshaling->variablePointers, sizeof(VkBool32));
 }
@@ -5820,14 +4709,7 @@ void unmarshal_VkPhysicalDeviceVariablePointerFeatures(
     VkPhysicalDeviceVariablePointerFeatures* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
     vkStream->read((VkBool32*)&forUnmarshaling->variablePointers, sizeof(VkBool32));
 }
@@ -5837,13 +4719,7 @@ void marshal_VkPhysicalDeviceProtectedMemoryFeatures(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->protectedMemory, sizeof(VkBool32));
 }
 
@@ -5852,14 +4728,7 @@ void unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
     VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->protectedMemory, sizeof(VkBool32));
 }
 
@@ -5868,13 +4737,7 @@ void marshal_VkPhysicalDeviceProtectedMemoryProperties(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->protectedNoFault, sizeof(VkBool32));
 }
 
@@ -5883,14 +4746,7 @@ void unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
     VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->protectedNoFault, sizeof(VkBool32));
 }
 
@@ -5899,13 +4755,7 @@ void marshal_VkDeviceQueueInfo2(
     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);
-    }
+    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));
@@ -5916,14 +4766,7 @@ void unmarshal_VkDeviceQueueInfo2(
     VkDeviceQueueInfo2* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -5934,13 +4777,7 @@ void marshal_VkProtectedSubmitInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->protectedSubmit, sizeof(VkBool32));
 }
 
@@ -5949,14 +4786,7 @@ void unmarshal_VkProtectedSubmitInfo(
     VkProtectedSubmitInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->protectedSubmit, sizeof(VkBool32));
 }
 
@@ -5965,13 +4795,7 @@ void marshal_VkSamplerYcbcrConversionCreateInfo(
     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);
-    }
+    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));
@@ -5987,14 +4811,7 @@ void unmarshal_VkSamplerYcbcrConversionCreateInfo(
     VkSamplerYcbcrConversionCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -6010,13 +4827,7 @@ void marshal_VkSamplerYcbcrConversionInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_178;
     vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion, &cgen_var_178, 1);
     vkStream->write((uint64_t*)&cgen_var_178, 1 * 8);
@@ -6027,14 +4838,7 @@ void unmarshal_VkSamplerYcbcrConversionInfo(
     VkSamplerYcbcrConversionInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_179;
     vkStream->read((uint64_t*)&cgen_var_179, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_179, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
@@ -6045,13 +4849,7 @@ void marshal_VkBindImagePlaneMemoryInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
 }
 
@@ -6060,14 +4858,7 @@ void unmarshal_VkBindImagePlaneMemoryInfo(
     VkBindImagePlaneMemoryInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
 }
 
@@ -6076,13 +4867,7 @@ void marshal_VkImagePlaneMemoryRequirementsInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
 }
 
@@ -6091,14 +4876,7 @@ void unmarshal_VkImagePlaneMemoryRequirementsInfo(
     VkImagePlaneMemoryRequirementsInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
 }
 
@@ -6107,13 +4885,7 @@ void marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->samplerYcbcrConversion, sizeof(VkBool32));
 }
 
@@ -6122,14 +4894,7 @@ void unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
     VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->samplerYcbcrConversion, sizeof(VkBool32));
 }
 
@@ -6138,13 +4903,7 @@ void marshal_VkSamplerYcbcrConversionImageFormatProperties(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->combinedImageSamplerDescriptorCount, sizeof(uint32_t));
 }
 
@@ -6153,14 +4912,7 @@ void unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
     VkSamplerYcbcrConversionImageFormatProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->combinedImageSamplerDescriptorCount, sizeof(uint32_t));
 }
 
@@ -6195,13 +4947,7 @@ void marshal_VkDescriptorUpdateTemplateCreateInfo(
     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);
-    }
+    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)
@@ -6224,14 +4970,7 @@ void unmarshal_VkDescriptorUpdateTemplateCreateInfo(
     VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDescriptorUpdateTemplateCreateFlags*)&forUnmarshaling->flags, sizeof(VkDescriptorUpdateTemplateCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorUpdateEntryCount; ++i)
@@ -6272,13 +5011,7 @@ void marshal_VkPhysicalDeviceExternalImageFormatInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
 }
 
@@ -6287,14 +5020,7 @@ void unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
     VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
 }
 
@@ -6303,13 +5029,7 @@ void marshal_VkExternalImageFormatProperties(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
 }
 
@@ -6318,14 +5038,7 @@ void unmarshal_VkExternalImageFormatProperties(
     VkExternalImageFormatProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
 }
 
@@ -6334,13 +5047,7 @@ void marshal_VkPhysicalDeviceExternalBufferInfo(
     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);
-    }
+    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));
@@ -6351,14 +5058,7 @@ void unmarshal_VkPhysicalDeviceExternalBufferInfo(
     VkPhysicalDeviceExternalBufferInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -6369,13 +5069,7 @@ void marshal_VkExternalBufferProperties(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
 }
 
@@ -6384,14 +5078,7 @@ void unmarshal_VkExternalBufferProperties(
     VkExternalBufferProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
 }
 
@@ -6400,13 +5087,7 @@ void marshal_VkPhysicalDeviceIDProperties(
     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);
-    }
+    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));
@@ -6419,14 +5100,7 @@ void unmarshal_VkPhysicalDeviceIDProperties(
     VkPhysicalDeviceIDProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -6439,13 +5113,7 @@ void marshal_VkExternalMemoryImageCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
 }
 
@@ -6454,14 +5122,7 @@ void unmarshal_VkExternalMemoryImageCreateInfo(
     VkExternalMemoryImageCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
 }
 
@@ -6470,13 +5131,7 @@ void marshal_VkExternalMemoryBufferCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
 }
 
@@ -6485,14 +5140,7 @@ void unmarshal_VkExternalMemoryBufferCreateInfo(
     VkExternalMemoryBufferCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
 }
 
@@ -6501,13 +5149,7 @@ void marshal_VkExportMemoryAllocateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
 }
 
@@ -6516,14 +5158,7 @@ void unmarshal_VkExportMemoryAllocateInfo(
     VkExportMemoryAllocateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
 }
 
@@ -6532,13 +5167,7 @@ void marshal_VkPhysicalDeviceExternalFenceInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
 }
 
@@ -6547,14 +5176,7 @@ void unmarshal_VkPhysicalDeviceExternalFenceInfo(
     VkPhysicalDeviceExternalFenceInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
 }
 
@@ -6563,13 +5185,7 @@ void marshal_VkExternalFenceProperties(
     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);
-    }
+    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));
@@ -6580,14 +5196,7 @@ void unmarshal_VkExternalFenceProperties(
     VkExternalFenceProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -6598,13 +5207,7 @@ void marshal_VkExportFenceCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalFenceHandleTypeFlags));
 }
 
@@ -6613,14 +5216,7 @@ void unmarshal_VkExportFenceCreateInfo(
     VkExportFenceCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalFenceHandleTypeFlags));
 }
 
@@ -6629,13 +5225,7 @@ void marshal_VkExportSemaphoreCreateInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
 }
 
@@ -6644,14 +5234,7 @@ void unmarshal_VkExportSemaphoreCreateInfo(
     VkExportSemaphoreCreateInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
 }
 
@@ -6660,13 +5243,7 @@ void marshal_VkPhysicalDeviceExternalSemaphoreInfo(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
 }
 
@@ -6675,14 +5252,7 @@ void unmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
     VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
 }
 
@@ -6691,13 +5261,7 @@ void marshal_VkExternalSemaphoreProperties(
     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);
-    }
+    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));
@@ -6708,14 +5272,7 @@ void unmarshal_VkExternalSemaphoreProperties(
     VkExternalSemaphoreProperties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -6726,13 +5283,7 @@ void marshal_VkPhysicalDeviceMaintenance3Properties(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->maxPerSetDescriptors, sizeof(uint32_t));
     vkStream->write((VkDeviceSize*)&forMarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
 }
@@ -6742,14 +5293,7 @@ void unmarshal_VkPhysicalDeviceMaintenance3Properties(
     VkPhysicalDeviceMaintenance3Properties* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->maxPerSetDescriptors, sizeof(uint32_t));
     vkStream->read((VkDeviceSize*)&forUnmarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
 }
@@ -6759,13 +5303,7 @@ void marshal_VkDescriptorSetLayoutSupport(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->supported, sizeof(VkBool32));
 }
 
@@ -6774,14 +5312,7 @@ void unmarshal_VkDescriptorSetLayoutSupport(
     VkDescriptorSetLayoutSupport* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->supported, sizeof(VkBool32));
 }
 
@@ -6790,13 +5321,7 @@ void marshal_VkPhysicalDeviceShaderDrawParameterFeatures(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->shaderDrawParameters, sizeof(VkBool32));
 }
 
@@ -6805,14 +5330,7 @@ void unmarshal_VkPhysicalDeviceShaderDrawParameterFeatures(
     VkPhysicalDeviceShaderDrawParameterFeatures* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->shaderDrawParameters, sizeof(VkBool32));
 }
 
@@ -6873,13 +5391,7 @@ void marshal_VkSwapchainCreateInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkSwapchainCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
     uint64_t cgen_var_188;
     vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_188, 1);
@@ -6913,14 +5425,7 @@ void unmarshal_VkSwapchainCreateInfoKHR(
     VkSwapchainCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkSwapchainCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
     uint64_t cgen_var_191;
     vkStream->read((uint64_t*)&cgen_var_191, 1 * 8);
@@ -6958,13 +5463,7 @@ void marshal_VkPresentInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
     if (forMarshaling->waitSemaphoreCount)
     {
@@ -6996,14 +5495,7 @@ void unmarshal_VkPresentInfoKHR(
     VkPresentInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
     if (forUnmarshaling->waitSemaphoreCount)
     {
@@ -7039,13 +5531,7 @@ void marshal_VkImageSwapchainCreateInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_200;
     vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_200, 1);
     vkStream->write((uint64_t*)&cgen_var_200, 1 * 8);
@@ -7056,14 +5542,7 @@ void unmarshal_VkImageSwapchainCreateInfoKHR(
     VkImageSwapchainCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_201;
     vkStream->read((uint64_t*)&cgen_var_201, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_201, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
@@ -7074,13 +5553,7 @@ void marshal_VkBindImageMemorySwapchainInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_202;
     vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_202, 1);
     vkStream->write((uint64_t*)&cgen_var_202, 1 * 8);
@@ -7092,14 +5565,7 @@ void unmarshal_VkBindImageMemorySwapchainInfoKHR(
     VkBindImageMemorySwapchainInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_203;
     vkStream->read((uint64_t*)&cgen_var_203, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_203, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
@@ -7111,13 +5577,7 @@ void marshal_VkAcquireNextImageInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_204;
     vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_204, 1);
     vkStream->write((uint64_t*)&cgen_var_204, 1 * 8);
@@ -7136,14 +5596,7 @@ void unmarshal_VkAcquireNextImageInfoKHR(
     VkAcquireNextImageInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_207;
     vkStream->read((uint64_t*)&cgen_var_207, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_207, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
@@ -7162,13 +5615,7 @@ void marshal_VkDeviceGroupPresentCapabilitiesKHR(
     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);
-    }
+    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));
 }
@@ -7178,14 +5625,7 @@ void unmarshal_VkDeviceGroupPresentCapabilitiesKHR(
     VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
 }
@@ -7195,13 +5635,7 @@ void marshal_VkDeviceGroupPresentInfoKHR(
     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);
-    }
+    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));
@@ -7212,14 +5646,7 @@ void unmarshal_VkDeviceGroupPresentInfoKHR(
     VkDeviceGroupPresentInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
     vkStream->read((uint32_t*)forUnmarshaling->pDeviceMasks, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
     vkStream->read((VkDeviceGroupPresentModeFlagBitsKHR*)&forUnmarshaling->mode, sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
@@ -7230,13 +5657,7 @@ void marshal_VkDeviceGroupSwapchainCreateInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
 }
 
@@ -7245,14 +5666,7 @@ void unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
     VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDeviceGroupPresentModeFlagsKHR*)&forUnmarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
 }
 
@@ -7329,13 +5743,7 @@ void marshal_VkDisplayModeCreateInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDisplayModeCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplayModeCreateFlagsKHR));
     marshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
 }
@@ -7345,14 +5753,7 @@ void unmarshal_VkDisplayModeCreateInfoKHR(
     VkDisplayModeCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDisplayModeCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplayModeCreateFlagsKHR));
     unmarshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
 }
@@ -7412,13 +5813,7 @@ void marshal_VkDisplaySurfaceCreateInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
     uint64_t cgen_var_216;
     vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_216, 1);
@@ -7436,14 +5831,7 @@ void unmarshal_VkDisplaySurfaceCreateInfoKHR(
     VkDisplaySurfaceCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDisplaySurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
     uint64_t cgen_var_217;
     vkStream->read((uint64_t*)&cgen_var_217, 1 * 8);
@@ -7463,13 +5851,7 @@ void marshal_VkDisplayPresentInfoKHR(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->srcRect));
     marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->dstRect));
     vkStream->write((VkBool32*)&forMarshaling->persistent, sizeof(VkBool32));
@@ -7480,14 +5862,7 @@ void unmarshal_VkDisplayPresentInfoKHR(
     VkDisplayPresentInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -7500,13 +5875,7 @@ void marshal_VkXlibSurfaceCreateInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
     uint64_t cgen_var_218 = (uint64_t)(uintptr_t)forMarshaling->dpy;
@@ -7523,14 +5892,7 @@ void unmarshal_VkXlibSurfaceCreateInfoKHR(
     VkXlibSurfaceCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkXlibSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
     Display* check_dpy;
@@ -7553,13 +5915,7 @@ void marshal_VkXcbSurfaceCreateInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkXcbSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
     uint64_t cgen_var_220 = (uint64_t)(uintptr_t)forMarshaling->connection;
@@ -7576,14 +5932,7 @@ void unmarshal_VkXcbSurfaceCreateInfoKHR(
     VkXcbSurfaceCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkXcbSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
     xcb_connection_t* check_connection;
@@ -7606,13 +5955,7 @@ void marshal_VkWaylandSurfaceCreateInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
     uint64_t cgen_var_222 = (uint64_t)(uintptr_t)forMarshaling->display;
@@ -7635,14 +5978,7 @@ void unmarshal_VkWaylandSurfaceCreateInfoKHR(
     VkWaylandSurfaceCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkWaylandSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
     wl_display* check_display;
@@ -7675,13 +6011,7 @@ void marshal_VkMirSurfaceCreateInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkMirSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkMirSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
     uint64_t cgen_var_226 = (uint64_t)(uintptr_t)forMarshaling->connection;
@@ -7704,14 +6034,7 @@ void unmarshal_VkMirSurfaceCreateInfoKHR(
     VkMirSurfaceCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkMirSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkMirSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
     MirConnection* check_connection;
@@ -7744,13 +6067,7 @@ void marshal_VkAndroidSurfaceCreateInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
     uint64_t cgen_var_230 = (uint64_t)(uintptr_t)forMarshaling->window;
@@ -7766,14 +6083,7 @@ void unmarshal_VkAndroidSurfaceCreateInfoKHR(
     VkAndroidSurfaceCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkAndroidSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
     ANativeWindow* check_window;
@@ -7795,13 +6105,7 @@ void marshal_VkWin32SurfaceCreateInfoKHR(
     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);
-    }
+    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));
@@ -7812,14 +6116,7 @@ void unmarshal_VkWin32SurfaceCreateInfoKHR(
     VkWin32SurfaceCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -7850,13 +6147,7 @@ void marshal_VkImportMemoryWin32HandleInfoKHR(
     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);
-    }
+    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));
@@ -7867,14 +6158,7 @@ void unmarshal_VkImportMemoryWin32HandleInfoKHR(
     VkImportMemoryWin32HandleInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -7885,13 +6169,7 @@ void marshal_VkExportMemoryWin32HandleInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     // WARNING PTR CHECK
     uint64_t cgen_var_232 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
     vkStream->putBe64(cgen_var_232);
@@ -7908,14 +6186,7 @@ void unmarshal_VkExportMemoryWin32HandleInfoKHR(
     VkExportMemoryWin32HandleInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     // WARNING PTR CHECK
     const SECURITY_ATTRIBUTES* check_pAttributes;
     check_pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
@@ -7936,13 +6207,7 @@ void marshal_VkMemoryWin32HandlePropertiesKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
 }
 
@@ -7951,14 +6216,7 @@ void unmarshal_VkMemoryWin32HandlePropertiesKHR(
     VkMemoryWin32HandlePropertiesKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
 }
 
@@ -7967,13 +6225,7 @@ void marshal_VkMemoryGetWin32HandleInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_234;
     vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_234, 1);
     vkStream->write((uint64_t*)&cgen_var_234, 1 * 8);
@@ -7985,14 +6237,7 @@ void unmarshal_VkMemoryGetWin32HandleInfoKHR(
     VkMemoryGetWin32HandleInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_235;
     vkStream->read((uint64_t*)&cgen_var_235, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_235, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
@@ -8006,13 +6251,7 @@ void marshal_VkImportMemoryFdInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
     vkStream->write((int*)&forMarshaling->fd, sizeof(int));
 }
@@ -8022,14 +6261,7 @@ void unmarshal_VkImportMemoryFdInfoKHR(
     VkImportMemoryFdInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
     vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
 }
@@ -8039,13 +6271,7 @@ void marshal_VkMemoryFdPropertiesKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
 }
 
@@ -8054,14 +6280,7 @@ void unmarshal_VkMemoryFdPropertiesKHR(
     VkMemoryFdPropertiesKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
 }
 
@@ -8070,13 +6289,7 @@ void marshal_VkMemoryGetFdInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_236;
     vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_236, 1);
     vkStream->write((uint64_t*)&cgen_var_236, 1 * 8);
@@ -8088,14 +6301,7 @@ void unmarshal_VkMemoryGetFdInfoKHR(
     VkMemoryGetFdInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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_VkDeviceMemory(&cgen_var_237, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
@@ -8109,13 +6315,7 @@ void marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
     if (forMarshaling->acquireCount)
     {
@@ -8142,14 +6342,7 @@ void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
     VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
     if (forUnmarshaling->acquireCount)
     {
@@ -8182,13 +6375,7 @@ void marshal_VkImportSemaphoreWin32HandleInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_242;
     vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_242, 1);
     vkStream->write((uint64_t*)&cgen_var_242, 1 * 8);
@@ -8203,14 +6390,7 @@ void unmarshal_VkImportSemaphoreWin32HandleInfoKHR(
     VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_243;
     vkStream->read((uint64_t*)&cgen_var_243, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_243, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
@@ -8225,13 +6405,7 @@ void marshal_VkExportSemaphoreWin32HandleInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     // WARNING PTR CHECK
     uint64_t cgen_var_244 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
     vkStream->putBe64(cgen_var_244);
@@ -8248,14 +6422,7 @@ void unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
     VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     // WARNING PTR CHECK
     const SECURITY_ATTRIBUTES* check_pAttributes;
     check_pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
@@ -8276,13 +6443,7 @@ void marshal_VkD3D12FenceSubmitInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
     // WARNING PTR CHECK
     uint64_t cgen_var_246 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
@@ -8306,14 +6467,7 @@ void unmarshal_VkD3D12FenceSubmitInfoKHR(
     VkD3D12FenceSubmitInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
     // WARNING PTR CHECK
     const uint64_t* check_pWaitSemaphoreValues;
@@ -8345,13 +6499,7 @@ void marshal_VkSemaphoreGetWin32HandleInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_250;
     vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_250, 1);
     vkStream->write((uint64_t*)&cgen_var_250, 1 * 8);
@@ -8363,14 +6511,7 @@ void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(
     VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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_VkSemaphore(&cgen_var_251, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
@@ -8384,13 +6525,7 @@ void marshal_VkImportSemaphoreFdInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_252;
     vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_252, 1);
     vkStream->write((uint64_t*)&cgen_var_252, 1 * 8);
@@ -8404,14 +6539,7 @@ void unmarshal_VkImportSemaphoreFdInfoKHR(
     VkImportSemaphoreFdInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_253;
     vkStream->read((uint64_t*)&cgen_var_253, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_253, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
@@ -8425,13 +6553,7 @@ void marshal_VkSemaphoreGetFdInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_254;
     vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_254, 1);
     vkStream->write((uint64_t*)&cgen_var_254, 1 * 8);
@@ -8443,14 +6565,7 @@ void unmarshal_VkSemaphoreGetFdInfoKHR(
     VkSemaphoreGetFdInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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_VkSemaphore(&cgen_var_255, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
@@ -8464,13 +6579,7 @@ void marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
 }
 
@@ -8479,14 +6588,7 @@ void unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
     VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->maxPushDescriptors, sizeof(uint32_t));
 }
 
@@ -8555,13 +6657,7 @@ void marshal_VkPresentRegionsKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
     // WARNING PTR CHECK
     uint64_t cgen_var_258 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
@@ -8580,14 +6676,7 @@ void unmarshal_VkPresentRegionsKHR(
     VkPresentRegionsKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
     // WARNING PTR CHECK
     const VkPresentRegionKHR* check_pRegions;
@@ -8614,13 +6703,7 @@ void marshal_VkAttachmentDescription2KHR(
     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);
-    }
+    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));
@@ -8637,14 +6720,7 @@ void unmarshal_VkAttachmentDescription2KHR(
     VkAttachmentDescription2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -8661,13 +6737,7 @@ void marshal_VkAttachmentReference2KHR(
     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);
-    }
+    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));
@@ -8678,14 +6748,7 @@ void unmarshal_VkAttachmentReference2KHR(
     VkAttachmentReference2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -8696,13 +6759,7 @@ void marshal_VkSubpassDescription2KHR(
     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);
-    }
+    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));
@@ -8742,14 +6799,7 @@ void unmarshal_VkSubpassDescription2KHR(
     VkSubpassDescription2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -8797,13 +6847,7 @@ void marshal_VkSubpassDependency2KHR(
     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);
-    }
+    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));
@@ -8819,14 +6863,7 @@ void unmarshal_VkSubpassDependency2KHR(
     VkSubpassDependency2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -8842,13 +6879,7 @@ void marshal_VkRenderPassCreateInfo2KHR(
     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);
-    }
+    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)
@@ -8874,14 +6905,7 @@ void unmarshal_VkRenderPassCreateInfo2KHR(
     VkRenderPassCreateInfo2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags, sizeof(VkRenderPassCreateFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
@@ -8907,13 +6931,7 @@ void marshal_VkSubpassBeginInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkSubpassContents*)&forMarshaling->contents, sizeof(VkSubpassContents));
 }
 
@@ -8922,14 +6940,7 @@ void unmarshal_VkSubpassBeginInfoKHR(
     VkSubpassBeginInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkSubpassContents*)&forUnmarshaling->contents, sizeof(VkSubpassContents));
 }
 
@@ -8938,13 +6949,7 @@ void marshal_VkSubpassEndInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
 }
 
 void unmarshal_VkSubpassEndInfoKHR(
@@ -8952,14 +6957,7 @@ void unmarshal_VkSubpassEndInfoKHR(
     VkSubpassEndInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
 }
 
 #endif
@@ -8969,13 +6967,7 @@ void marshal_VkSharedPresentSurfaceCapabilitiesKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkImageUsageFlags*)&forMarshaling->sharedPresentSupportedUsageFlags, sizeof(VkImageUsageFlags));
 }
 
@@ -8984,14 +6976,7 @@ void unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
     VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkImageUsageFlags*)&forUnmarshaling->sharedPresentSupportedUsageFlags, sizeof(VkImageUsageFlags));
 }
 
@@ -9006,13 +6991,7 @@ void marshal_VkImportFenceWin32HandleInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_264;
     vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_264, 1);
     vkStream->write((uint64_t*)&cgen_var_264, 1 * 8);
@@ -9027,14 +7006,7 @@ void unmarshal_VkImportFenceWin32HandleInfoKHR(
     VkImportFenceWin32HandleInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_265;
     vkStream->read((uint64_t*)&cgen_var_265, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_265, (VkFence*)&forUnmarshaling->fence, 1);
@@ -9049,13 +7021,7 @@ void marshal_VkExportFenceWin32HandleInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     // WARNING PTR CHECK
     uint64_t cgen_var_266 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
     vkStream->putBe64(cgen_var_266);
@@ -9072,14 +7038,7 @@ void unmarshal_VkExportFenceWin32HandleInfoKHR(
     VkExportFenceWin32HandleInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     // WARNING PTR CHECK
     const SECURITY_ATTRIBUTES* check_pAttributes;
     check_pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
@@ -9100,13 +7059,7 @@ void marshal_VkFenceGetWin32HandleInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_268;
     vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_268, 1);
     vkStream->write((uint64_t*)&cgen_var_268, 1 * 8);
@@ -9118,14 +7071,7 @@ void unmarshal_VkFenceGetWin32HandleInfoKHR(
     VkFenceGetWin32HandleInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_269;
     vkStream->read((uint64_t*)&cgen_var_269, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_269, (VkFence*)&forUnmarshaling->fence, 1);
@@ -9139,13 +7085,7 @@ void marshal_VkImportFenceFdInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_270;
     vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_270, 1);
     vkStream->write((uint64_t*)&cgen_var_270, 1 * 8);
@@ -9159,14 +7099,7 @@ void unmarshal_VkImportFenceFdInfoKHR(
     VkImportFenceFdInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_271;
     vkStream->read((uint64_t*)&cgen_var_271, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_271, (VkFence*)&forUnmarshaling->fence, 1);
@@ -9180,13 +7113,7 @@ void marshal_VkFenceGetFdInfoKHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_272;
     vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_272, 1);
     vkStream->write((uint64_t*)&cgen_var_272, 1 * 8);
@@ -9198,14 +7125,7 @@ void unmarshal_VkFenceGetFdInfoKHR(
     VkFenceGetFdInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_273;
     vkStream->read((uint64_t*)&cgen_var_273, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_273, (VkFence*)&forUnmarshaling->fence, 1);
@@ -9221,13 +7141,7 @@ void marshal_VkPhysicalDeviceSurfaceInfo2KHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_274;
     vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_274, 1);
     vkStream->write((uint64_t*)&cgen_var_274, 1 * 8);
@@ -9238,14 +7152,7 @@ void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
     VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_275;
     vkStream->read((uint64_t*)&cgen_var_275, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_275, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
@@ -9256,13 +7163,7 @@ void marshal_VkSurfaceCapabilities2KHR(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkSurfaceCapabilitiesKHR(vkStream, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities));
 }
 
@@ -9271,14 +7172,7 @@ void unmarshal_VkSurfaceCapabilities2KHR(
     VkSurfaceCapabilities2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkSurfaceCapabilitiesKHR(vkStream, (VkSurfaceCapabilitiesKHR*)(&forUnmarshaling->surfaceCapabilities));
 }
 
@@ -9287,13 +7181,7 @@ void marshal_VkSurfaceFormat2KHR(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkSurfaceFormatKHR(vkStream, (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat));
 }
 
@@ -9302,14 +7190,7 @@ void unmarshal_VkSurfaceFormat2KHR(
     VkSurfaceFormat2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkSurfaceFormatKHR(vkStream, (VkSurfaceFormatKHR*)(&forUnmarshaling->surfaceFormat));
 }
 
@@ -9322,13 +7203,7 @@ void marshal_VkDisplayProperties2KHR(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkDisplayPropertiesKHR(vkStream, (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties));
 }
 
@@ -9337,14 +7212,7 @@ void unmarshal_VkDisplayProperties2KHR(
     VkDisplayProperties2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkDisplayPropertiesKHR(vkStream, (VkDisplayPropertiesKHR*)(&forUnmarshaling->displayProperties));
 }
 
@@ -9353,13 +7221,7 @@ void marshal_VkDisplayPlaneProperties2KHR(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkDisplayPlanePropertiesKHR(vkStream, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties));
 }
 
@@ -9368,14 +7230,7 @@ void unmarshal_VkDisplayPlaneProperties2KHR(
     VkDisplayPlaneProperties2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkDisplayPlanePropertiesKHR(vkStream, (VkDisplayPlanePropertiesKHR*)(&forUnmarshaling->displayPlaneProperties));
 }
 
@@ -9384,13 +7239,7 @@ void marshal_VkDisplayModeProperties2KHR(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkDisplayModePropertiesKHR(vkStream, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties));
 }
 
@@ -9399,14 +7248,7 @@ void unmarshal_VkDisplayModeProperties2KHR(
     VkDisplayModeProperties2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkDisplayModePropertiesKHR(vkStream, (VkDisplayModePropertiesKHR*)(&forUnmarshaling->displayModeProperties));
 }
 
@@ -9415,13 +7257,7 @@ void marshal_VkDisplayPlaneInfo2KHR(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_276;
     vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_276, 1);
     vkStream->write((uint64_t*)&cgen_var_276, 1 * 8);
@@ -9433,14 +7269,7 @@ void unmarshal_VkDisplayPlaneInfo2KHR(
     VkDisplayPlaneInfo2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_277;
     vkStream->read((uint64_t*)&cgen_var_277, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_277, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
@@ -9452,13 +7281,7 @@ void marshal_VkDisplayPlaneCapabilities2KHR(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkDisplayPlaneCapabilitiesKHR(vkStream, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities));
 }
 
@@ -9467,14 +7290,7 @@ void unmarshal_VkDisplayPlaneCapabilities2KHR(
     VkDisplayPlaneCapabilities2KHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkDisplayPlaneCapabilitiesKHR(vkStream, (VkDisplayPlaneCapabilitiesKHR*)(&forUnmarshaling->capabilities));
 }
 
@@ -9493,13 +7309,7 @@ void marshal_VkImageFormatListCreateInfoKHR(
     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);
-    }
+    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));
 }
@@ -9509,14 +7319,7 @@ void unmarshal_VkImageFormatListCreateInfoKHR(
     VkImageFormatListCreateInfoKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->viewFormatCount, sizeof(uint32_t));
     vkStream->read((VkFormat*)forUnmarshaling->pViewFormats, forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
 }
@@ -9536,13 +7339,7 @@ void marshal_VkPhysicalDevice8BitStorageFeaturesKHR(
     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);
-    }
+    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));
@@ -9553,33 +7350,42 @@ void unmarshal_VkPhysicalDevice8BitStorageFeaturesKHR(
     VkPhysicalDevice8BitStorageFeaturesKHR* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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_KHR_shader_float16_int8
+void marshal_VkPhysicalDeviceShaderFloat16Int8Features(
+    VulkanStreamGuest* vkStream,
+    const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling)
+{
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderFloat16, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderInt8, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
+    VulkanStreamGuest* vkStream,
+    VkPhysicalDeviceShaderFloat16Int8Features* forUnmarshaling)
+{
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderFloat16, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderInt8, sizeof(VkBool32));
+}
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void marshal_VkNativeBufferANDROID(
     VulkanStreamGuest* 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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     // WARNING PTR CHECK
     uint64_t cgen_var_278 = (uint64_t)(uintptr_t)forMarshaling->handle;
     vkStream->putBe64(cgen_var_278);
@@ -9599,14 +7405,7 @@ void unmarshal_VkNativeBufferANDROID(
     VkNativeBufferANDROID* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     // WARNING PTR CHECK
     const uint32_t* check_handle;
     check_handle = (const uint32_t*)(uintptr_t)vkStream->getBe64();
@@ -9632,13 +7431,7 @@ void marshal_VkDebugReportCallbackCreateInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDebugReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugReportFlagsEXT));
     uint64_t cgen_var_280 = (uint64_t)forMarshaling->pfnCallback;
     vkStream->putBe64(cgen_var_280);
@@ -9656,14 +7449,7 @@ void unmarshal_VkDebugReportCallbackCreateInfoEXT(
     VkDebugReportCallbackCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDebugReportFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugReportFlagsEXT));
     forUnmarshaling->pfnCallback = (PFN_vkDebugReportCallbackEXT)vkStream->getBe64();
     // WARNING PTR CHECK
@@ -9692,13 +7478,7 @@ void marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkRasterizationOrderAMD*)&forMarshaling->rasterizationOrder, sizeof(VkRasterizationOrderAMD));
 }
 
@@ -9707,14 +7487,7 @@ void unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
     VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkRasterizationOrderAMD*)&forUnmarshaling->rasterizationOrder, sizeof(VkRasterizationOrderAMD));
 }
 
@@ -9729,13 +7502,7 @@ void marshal_VkDebugMarkerObjectNameInfoEXT(
     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);
-    }
+    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);
@@ -9746,14 +7513,7 @@ void unmarshal_VkDebugMarkerObjectNameInfoEXT(
     VkDebugMarkerObjectNameInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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);
@@ -9764,13 +7524,7 @@ void marshal_VkDebugMarkerObjectTagInfoEXT(
     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);
-    }
+    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));
@@ -9784,14 +7538,7 @@ void unmarshal_VkDebugMarkerObjectTagInfoEXT(
     VkDebugMarkerObjectTagInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -9804,13 +7551,7 @@ void marshal_VkDebugMarkerMarkerInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->putString(forMarshaling->pMarkerName);
     vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
 }
@@ -9820,14 +7561,7 @@ void unmarshal_VkDebugMarkerMarkerInfoEXT(
     VkDebugMarkerMarkerInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->loadStringInPlace((char**)&forUnmarshaling->pMarkerName);
     vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
 }
@@ -9841,13 +7575,7 @@ void marshal_VkDedicatedAllocationImageCreateInfoNV(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
 }
 
@@ -9856,14 +7584,7 @@ void unmarshal_VkDedicatedAllocationImageCreateInfoNV(
     VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocation, sizeof(VkBool32));
 }
 
@@ -9872,13 +7593,7 @@ void marshal_VkDedicatedAllocationBufferCreateInfoNV(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
 }
 
@@ -9887,14 +7602,7 @@ void unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
     VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocation, sizeof(VkBool32));
 }
 
@@ -9903,13 +7611,7 @@ void marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_286;
     vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_286, 1);
     vkStream->write((uint64_t*)&cgen_var_286, 1 * 8);
@@ -9923,14 +7625,7 @@ void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
     VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_288;
     vkStream->read((uint64_t*)&cgen_var_288, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_288, (VkImage*)&forUnmarshaling->image, 1);
@@ -9954,13 +7649,7 @@ void marshal_VkTextureLODGatherFormatPropertiesAMD(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
 }
 
@@ -9969,14 +7658,7 @@ void unmarshal_VkTextureLODGatherFormatPropertiesAMD(
     VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
 }
 
@@ -10065,13 +7747,7 @@ void marshal_VkExternalMemoryImageCreateInfoNV(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
 }
 
@@ -10080,14 +7756,7 @@ void unmarshal_VkExternalMemoryImageCreateInfoNV(
     VkExternalMemoryImageCreateInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
 }
 
@@ -10096,13 +7765,7 @@ void marshal_VkExportMemoryAllocateInfoNV(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
 }
 
@@ -10111,14 +7774,7 @@ void unmarshal_VkExportMemoryAllocateInfoNV(
     VkExportMemoryAllocateInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
 }
 
@@ -10129,13 +7785,7 @@ void marshal_VkImportMemoryWin32HandleInfoNV(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
     vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
 }
@@ -10145,14 +7795,7 @@ void unmarshal_VkImportMemoryWin32HandleInfoNV(
     VkImportMemoryWin32HandleInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
     vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
 }
@@ -10162,13 +7805,7 @@ void marshal_VkExportMemoryWin32HandleInfoNV(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     // WARNING PTR CHECK
     uint64_t cgen_var_294 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
     vkStream->putBe64(cgen_var_294);
@@ -10184,14 +7821,7 @@ void unmarshal_VkExportMemoryWin32HandleInfoNV(
     VkExportMemoryWin32HandleInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     // WARNING PTR CHECK
     const SECURITY_ATTRIBUTES* check_pAttributes;
     check_pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
@@ -10213,13 +7843,7 @@ void marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
     if (forMarshaling->acquireCount)
     {
@@ -10246,14 +7870,7 @@ void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
     VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
     if (forUnmarshaling->acquireCount)
     {
@@ -10282,13 +7899,7 @@ void marshal_VkValidationFlagsEXT(
     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);
-    }
+    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));
 }
@@ -10298,14 +7909,7 @@ void unmarshal_VkValidationFlagsEXT(
     VkValidationFlagsEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->disabledValidationCheckCount, sizeof(uint32_t));
     vkStream->read((VkValidationCheckEXT*)forUnmarshaling->pDisabledValidationChecks, forUnmarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
 }
@@ -10317,13 +7921,7 @@ void marshal_VkViSurfaceCreateInfoNN(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkViSurfaceCreateFlagsNN*)&forMarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
     // WARNING PTR CHECK
     uint64_t cgen_var_300 = (uint64_t)(uintptr_t)forMarshaling->window;
@@ -10339,14 +7937,7 @@ void unmarshal_VkViSurfaceCreateInfoNN(
     VkViSurfaceCreateInfoNN* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkViSurfaceCreateFlagsNN*)&forUnmarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
     // WARNING PTR CHECK
     void* check_window;
@@ -10372,13 +7963,7 @@ void marshal_VkConditionalRenderingBeginInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_302;
     vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_302, 1);
     vkStream->write((uint64_t*)&cgen_var_302, 1 * 8);
@@ -10391,14 +7976,7 @@ void unmarshal_VkConditionalRenderingBeginInfoEXT(
     VkConditionalRenderingBeginInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_303;
     vkStream->read((uint64_t*)&cgen_var_303, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_303, (VkBuffer*)&forUnmarshaling->buffer, 1);
@@ -10411,13 +7989,7 @@ void marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->conditionalRendering, sizeof(VkBool32));
     vkStream->write((VkBool32*)&forMarshaling->inheritedConditionalRendering, sizeof(VkBool32));
 }
@@ -10427,14 +7999,7 @@ void unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
     VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->conditionalRendering, sizeof(VkBool32));
     vkStream->read((VkBool32*)&forUnmarshaling->inheritedConditionalRendering, sizeof(VkBool32));
 }
@@ -10444,13 +8009,7 @@ void marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->conditionalRenderingEnable, sizeof(VkBool32));
 }
 
@@ -10459,14 +8018,7 @@ void unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
     VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->conditionalRenderingEnable, sizeof(VkBool32));
 }
 
@@ -10477,13 +8029,7 @@ void marshal_VkDeviceGeneratedCommandsFeaturesNVX(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->computeBindingPointSupport, sizeof(VkBool32));
 }
 
@@ -10492,14 +8038,7 @@ void unmarshal_VkDeviceGeneratedCommandsFeaturesNVX(
     VkDeviceGeneratedCommandsFeaturesNVX* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->computeBindingPointSupport, sizeof(VkBool32));
 }
 
@@ -10508,13 +8047,7 @@ void marshal_VkDeviceGeneratedCommandsLimitsNVX(
     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);
-    }
+    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));
@@ -10527,14 +8060,7 @@ void unmarshal_VkDeviceGeneratedCommandsLimitsNVX(
     VkDeviceGeneratedCommandsLimitsNVX* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -10589,13 +8115,7 @@ void marshal_VkIndirectCommandsLayoutCreateInfoNVX(
     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);
-    }
+    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));
@@ -10610,14 +8130,7 @@ void unmarshal_VkIndirectCommandsLayoutCreateInfoNVX(
     VkIndirectCommandsLayoutCreateInfoNVX* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -10632,13 +8145,7 @@ void marshal_VkCmdProcessCommandsInfoNVX(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_306;
     vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_306, 1);
     vkStream->write((uint64_t*)&cgen_var_306, 1 * 8);
@@ -10669,14 +8176,7 @@ void unmarshal_VkCmdProcessCommandsInfoNVX(
     VkCmdProcessCommandsInfoNVX* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_311;
     vkStream->read((uint64_t*)&cgen_var_311, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_311, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
@@ -10707,13 +8207,7 @@ void marshal_VkCmdReserveSpaceForCommandsInfoNVX(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_316;
     vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_316, 1);
     vkStream->write((uint64_t*)&cgen_var_316, 1 * 8);
@@ -10728,14 +8222,7 @@ void unmarshal_VkCmdReserveSpaceForCommandsInfoNVX(
     VkCmdReserveSpaceForCommandsInfoNVX* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_318;
     vkStream->read((uint64_t*)&cgen_var_318, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_318, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
@@ -10750,13 +8237,7 @@ void marshal_VkObjectTableCreateInfoNVX(
     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);
-    }
+    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));
@@ -10773,14 +8254,7 @@ void unmarshal_VkObjectTableCreateInfoNVX(
     VkObjectTableCreateInfoNVX* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->objectCount, sizeof(uint32_t));
     vkStream->read((VkObjectEntryTypeNVX*)forUnmarshaling->pObjectEntryTypes, forUnmarshaling->objectCount * sizeof(const VkObjectEntryTypeNVX));
     vkStream->read((uint32_t*)forUnmarshaling->pObjectEntryCounts, forUnmarshaling->objectCount * sizeof(const uint32_t));
@@ -10951,13 +8425,7 @@ void marshal_VkPipelineViewportWScalingStateCreateInfoNV(
     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);
-    }
+    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
@@ -10977,14 +8445,7 @@ void unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
     VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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
@@ -11014,13 +8475,7 @@ void marshal_VkSurfaceCapabilities2EXT(
     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);
-    }
+    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));
@@ -11039,14 +8494,7 @@ void unmarshal_VkSurfaceCapabilities2EXT(
     VkSurfaceCapabilities2EXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -11067,13 +8515,7 @@ void marshal_VkDisplayPowerInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDisplayPowerStateEXT*)&forMarshaling->powerState, sizeof(VkDisplayPowerStateEXT));
 }
 
@@ -11082,14 +8524,7 @@ void unmarshal_VkDisplayPowerInfoEXT(
     VkDisplayPowerInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDisplayPowerStateEXT*)&forUnmarshaling->powerState, sizeof(VkDisplayPowerStateEXT));
 }
 
@@ -11098,13 +8533,7 @@ void marshal_VkDeviceEventInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDeviceEventTypeEXT*)&forMarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
 }
 
@@ -11113,14 +8542,7 @@ void unmarshal_VkDeviceEventInfoEXT(
     VkDeviceEventInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDeviceEventTypeEXT*)&forUnmarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
 }
 
@@ -11129,13 +8551,7 @@ void marshal_VkDisplayEventInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDisplayEventTypeEXT*)&forMarshaling->displayEvent, sizeof(VkDisplayEventTypeEXT));
 }
 
@@ -11144,14 +8560,7 @@ void unmarshal_VkDisplayEventInfoEXT(
     VkDisplayEventInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDisplayEventTypeEXT*)&forUnmarshaling->displayEvent, sizeof(VkDisplayEventTypeEXT));
 }
 
@@ -11160,13 +8569,7 @@ void marshal_VkSwapchainCounterCreateInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->surfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
 }
 
@@ -11175,14 +8578,7 @@ void unmarshal_VkSwapchainCounterCreateInfoEXT(
     VkSwapchainCounterCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->surfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
 }
 
@@ -11245,13 +8641,7 @@ void marshal_VkPresentTimesInfoGOOGLE(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
     // WARNING PTR CHECK
     uint64_t cgen_var_334 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
@@ -11270,14 +8660,7 @@ void unmarshal_VkPresentTimesInfoGOOGLE(
     VkPresentTimesInfoGOOGLE* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
     // WARNING PTR CHECK
     const VkPresentTimeGOOGLE* check_pTimes;
@@ -11308,13 +8691,7 @@ void marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->perViewPositionAllComponents, sizeof(VkBool32));
 }
 
@@ -11323,14 +8700,7 @@ void unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
     VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->perViewPositionAllComponents, sizeof(VkBool32));
 }
 
@@ -11361,13 +8731,7 @@ void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
     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);
-    }
+    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
@@ -11387,14 +8751,7 @@ void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
     VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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
@@ -11420,13 +8777,7 @@ void marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->maxDiscardRectangles, sizeof(uint32_t));
 }
 
@@ -11435,14 +8786,7 @@ void unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
     VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->maxDiscardRectangles, sizeof(uint32_t));
 }
 
@@ -11451,13 +8795,7 @@ void marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
     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);
-    }
+    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));
@@ -11478,14 +8816,7 @@ void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
     VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -11512,13 +8843,7 @@ void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
     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);
-    }
+    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));
@@ -11535,14 +8860,7 @@ void unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
     VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -11559,13 +8877,7 @@ void marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
     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);
-    }
+    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));
@@ -11576,14 +8888,7 @@ void unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
     VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -11614,13 +8919,7 @@ void marshal_VkHdrMetadataEXT(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryRed));
     marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryGreen));
     marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryBlue));
@@ -11636,14 +8935,7 @@ void unmarshal_VkHdrMetadataEXT(
     VkHdrMetadataEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -11661,13 +8953,7 @@ void marshal_VkIOSSurfaceCreateInfoMVK(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
     // WARNING PTR CHECK
     uint64_t cgen_var_340 = (uint64_t)(uintptr_t)forMarshaling->pView;
@@ -11683,14 +8969,7 @@ void unmarshal_VkIOSSurfaceCreateInfoMVK(
     VkIOSSurfaceCreateInfoMVK* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkIOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
     // WARNING PTR CHECK
     const void* check_pView;
@@ -11712,13 +8991,7 @@ void marshal_VkMacOSSurfaceCreateInfoMVK(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
     // WARNING PTR CHECK
     uint64_t cgen_var_342 = (uint64_t)(uintptr_t)forMarshaling->pView;
@@ -11734,14 +9007,7 @@ void unmarshal_VkMacOSSurfaceCreateInfoMVK(
     VkMacOSSurfaceCreateInfoMVK* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkMacOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
     // WARNING PTR CHECK
     const void* check_pView;
@@ -11767,13 +9033,7 @@ void marshal_VkDebugUtilsObjectNameInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
     vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
     if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
@@ -11797,14 +9057,7 @@ void unmarshal_VkDebugUtilsObjectNameInfoEXT(
     VkDebugUtilsObjectNameInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
     vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
     if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
@@ -11832,13 +9085,7 @@ void marshal_VkDebugUtilsObjectTagInfoEXT(
     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);
-    }
+    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));
@@ -11852,14 +9099,7 @@ void unmarshal_VkDebugUtilsObjectTagInfoEXT(
     VkDebugUtilsObjectTagInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -11872,13 +9112,7 @@ void marshal_VkDebugUtilsLabelEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->putString(forMarshaling->pLabelName);
     vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
 }
@@ -11888,14 +9122,7 @@ void unmarshal_VkDebugUtilsLabelEXT(
     VkDebugUtilsLabelEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->loadStringInPlace((char**)&forUnmarshaling->pLabelName);
     vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
 }
@@ -11905,13 +9132,7 @@ void marshal_VkDebugUtilsMessengerCallbackDataEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
     if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
     {
@@ -11969,14 +9190,7 @@ void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
     VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
     if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
     {
@@ -12050,13 +9264,7 @@ void marshal_VkDebugUtilsMessengerCreateInfoEXT(
     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);
-    }
+    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));
@@ -12076,14 +9284,7 @@ void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
     VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -12108,13 +9309,7 @@ void marshal_VkAndroidHardwareBufferUsageANDROID(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint64_t*)&forMarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
 }
 
@@ -12123,14 +9318,7 @@ void unmarshal_VkAndroidHardwareBufferUsageANDROID(
     VkAndroidHardwareBufferUsageANDROID* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint64_t*)&forUnmarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
 }
 
@@ -12139,13 +9327,7 @@ void marshal_VkAndroidHardwareBufferPropertiesANDROID(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
     vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
 }
@@ -12155,14 +9337,7 @@ void unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
     VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDeviceSize*)&forUnmarshaling->allocationSize, sizeof(VkDeviceSize));
     vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
 }
@@ -12172,13 +9347,7 @@ void marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
     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);
-    }
+    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));
@@ -12194,14 +9363,7 @@ void unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
     VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -12217,13 +9379,7 @@ void marshal_VkImportAndroidHardwareBufferInfoANDROID(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((AHardwareBuffer*)forMarshaling->buffer, sizeof(AHardwareBuffer));
 }
 
@@ -12232,14 +9388,7 @@ void unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
     VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((AHardwareBuffer*)forUnmarshaling->buffer, sizeof(AHardwareBuffer));
 }
 
@@ -12248,13 +9397,7 @@ void marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_360;
     vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_360, 1);
     vkStream->write((uint64_t*)&cgen_var_360, 1 * 8);
@@ -12265,14 +9408,7 @@ void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
     VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_361;
     vkStream->read((uint64_t*)&cgen_var_361, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_361, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
@@ -12283,13 +9419,7 @@ void marshal_VkExternalFormatANDROID(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
 }
 
@@ -12298,14 +9428,7 @@ void unmarshal_VkExternalFormatANDROID(
     VkExternalFormatANDROID* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
 }
 
@@ -12316,13 +9439,7 @@ void marshal_VkSamplerReductionModeCreateInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkSamplerReductionModeEXT*)&forMarshaling->reductionMode, sizeof(VkSamplerReductionModeEXT));
 }
 
@@ -12331,14 +9448,7 @@ void unmarshal_VkSamplerReductionModeCreateInfoEXT(
     VkSamplerReductionModeCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkSamplerReductionModeEXT*)&forUnmarshaling->reductionMode, sizeof(VkSamplerReductionModeEXT));
 }
 
@@ -12347,13 +9457,7 @@ void marshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
     vkStream->write((VkBool32*)&forMarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
 }
@@ -12363,14 +9467,7 @@ void unmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
     VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
     vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
 }
@@ -12406,13 +9503,7 @@ void marshal_VkSampleLocationsInfoEXT(
     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);
-    }
+    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));
@@ -12427,14 +9518,7 @@ void unmarshal_VkSampleLocationsInfoEXT(
     VkSampleLocationsInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -12481,13 +9565,7 @@ void marshal_VkRenderPassSampleLocationsBeginInfoEXT(
     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);
-    }
+    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)
     {
@@ -12505,14 +9583,7 @@ void unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
     VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->attachmentInitialSampleLocationsCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentInitialSampleLocationsCount; ++i)
     {
@@ -12530,13 +9601,7 @@ void marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->sampleLocationsEnable, sizeof(VkBool32));
     marshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
 }
@@ -12546,14 +9611,7 @@ void unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
     VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->sampleLocationsEnable, sizeof(VkBool32));
     unmarshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
 }
@@ -12563,13 +9621,7 @@ void marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
     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);
-    }
+    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));
@@ -12582,14 +9634,7 @@ void unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
     VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -12602,13 +9647,7 @@ void marshal_VkMultisamplePropertiesEXT(
     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_extension_struct(vkStream, forMarshaling->pNext);
     marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
 }
 
@@ -12617,14 +9656,7 @@ void unmarshal_VkMultisamplePropertiesEXT(
     VkMultisamplePropertiesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
 }
 
@@ -12635,13 +9667,7 @@ void marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkBool32*)&forMarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
 }
 
@@ -12650,14 +9676,7 @@ void unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
     VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
 }
 
@@ -12666,13 +9685,7 @@ void marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
     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);
-    }
+    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));
@@ -12686,14 +9699,7 @@ void unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
     VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -12707,13 +9713,7 @@ void marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
     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);
-    }
+    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));
@@ -12724,14 +9724,7 @@ void unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
     VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -12744,13 +9737,7 @@ void marshal_VkPipelineCoverageToColorStateCreateInfoNV(
     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);
-    }
+    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));
@@ -12761,14 +9748,7 @@ void unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
     VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -12781,13 +9761,7 @@ void marshal_VkPipelineCoverageModulationStateCreateInfoNV(
     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);
-    }
+    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));
@@ -12806,14 +9780,7 @@ void unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
     VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -12842,13 +9809,7 @@ void marshal_VkValidationCacheCreateInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
     uint64_t cgen_var_364 = (uint64_t)forMarshaling->initialDataSize;
     vkStream->putBe64(cgen_var_364);
@@ -12860,14 +9821,7 @@ void unmarshal_VkValidationCacheCreateInfoEXT(
     VkValidationCacheCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkValidationCacheCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
     forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
     vkStream->read((void*)forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
@@ -12878,13 +9832,7 @@ void marshal_VkShaderModuleValidationCacheCreateInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     uint64_t cgen_var_366;
     vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache, &cgen_var_366, 1);
     vkStream->write((uint64_t*)&cgen_var_366, 1 * 8);
@@ -12895,14 +9843,7 @@ void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
     VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     uint64_t cgen_var_367;
     vkStream->read((uint64_t*)&cgen_var_367, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_367, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
@@ -12915,13 +9856,7 @@ void marshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
     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);
-    }
+    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));
 }
@@ -12931,14 +9866,7 @@ void unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
     VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
     vkStream->read((VkDescriptorBindingFlagsEXT*)forUnmarshaling->pBindingFlags, forUnmarshaling->bindingCount * sizeof(const VkDescriptorBindingFlagsEXT));
 }
@@ -12948,13 +9876,7 @@ void marshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
     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);
-    }
+    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));
@@ -12982,14 +9904,7 @@ void unmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
     VkPhysicalDeviceDescriptorIndexingFeaturesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -13017,13 +9932,7 @@ void marshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
     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);
-    }
+    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));
@@ -13054,14 +9963,7 @@ void unmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
     VkPhysicalDeviceDescriptorIndexingPropertiesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -13092,13 +9994,7 @@ void marshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
     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);
-    }
+    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));
 }
@@ -13108,14 +10004,7 @@ void unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
     VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
     vkStream->read((uint32_t*)forUnmarshaling->pDescriptorCounts, forUnmarshaling->descriptorSetCount * sizeof(const uint32_t));
 }
@@ -13125,13 +10014,7 @@ void marshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
 }
 
@@ -13140,14 +10023,7 @@ void unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
     VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
 }
 
@@ -13160,13 +10036,7 @@ void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkQueueGlobalPriorityEXT*)&forMarshaling->globalPriority, sizeof(VkQueueGlobalPriorityEXT));
 }
 
@@ -13175,14 +10045,7 @@ void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
     VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkQueueGlobalPriorityEXT*)&forUnmarshaling->globalPriority, sizeof(VkQueueGlobalPriorityEXT));
 }
 
@@ -13193,13 +10056,7 @@ void marshal_VkImportMemoryHostPointerInfoEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
     // WARNING PTR CHECK
     uint64_t cgen_var_368 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
@@ -13215,14 +10072,7 @@ void unmarshal_VkImportMemoryHostPointerInfoEXT(
     VkImportMemoryHostPointerInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
     // WARNING PTR CHECK
     void* check_pHostPointer;
@@ -13242,13 +10092,7 @@ void marshal_VkMemoryHostPointerPropertiesEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
 }
 
@@ -13257,14 +10101,7 @@ void unmarshal_VkMemoryHostPointerPropertiesEXT(
     VkMemoryHostPointerPropertiesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
 }
 
@@ -13273,13 +10110,7 @@ void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkDeviceSize*)&forMarshaling->minImportedHostPointerAlignment, sizeof(VkDeviceSize));
 }
 
@@ -13288,14 +10119,7 @@ void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
     VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkDeviceSize*)&forUnmarshaling->minImportedHostPointerAlignment, sizeof(VkDeviceSize));
 }
 
@@ -13308,13 +10132,7 @@ void marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
     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);
-    }
+    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));
@@ -13336,14 +10154,7 @@ void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
     VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    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));
@@ -13367,13 +10178,7 @@ void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
 }
 
@@ -13382,14 +10187,7 @@ void unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
     VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
 }
 
@@ -13414,13 +10212,7 @@ void marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
     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);
-    }
+    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)
     {
@@ -13433,14 +10225,7 @@ void unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
     VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDivisorCount; ++i)
     {
@@ -13457,13 +10242,7 @@ void marshal_VkQueueFamilyCheckpointPropertiesNV(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkPipelineStageFlags*)&forMarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags));
 }
 
@@ -13472,14 +10251,7 @@ void unmarshal_VkQueueFamilyCheckpointPropertiesNV(
     VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags));
 }
 
@@ -13488,13 +10260,7 @@ void marshal_VkCheckpointDataNV(
     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);
-    }
+    marshal_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((VkPipelineStageFlagBits*)&forMarshaling->stage, sizeof(VkPipelineStageFlagBits));
     // WARNING PTR CHECK
     uint64_t cgen_var_370 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
@@ -13510,14 +10276,7 @@ void unmarshal_VkCheckpointDataNV(
     VkCheckpointDataNV* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((VkPipelineStageFlagBits*)&forUnmarshaling->stage, sizeof(VkPipelineStageFlagBits));
     // WARNING PTR CHECK
     void* check_pCheckpointMarker;
@@ -13541,13 +10300,7 @@ void marshal_VkImportColorBufferGOOGLE(
     const VkImportColorBufferGOOGLE* 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_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->colorBuffer, sizeof(uint32_t));
 }
 
@@ -13556,14 +10309,7 @@ void unmarshal_VkImportColorBufferGOOGLE(
     VkImportColorBufferGOOGLE* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->colorBuffer, sizeof(uint32_t));
 }
 
@@ -13572,13 +10318,7 @@ void marshal_VkImportBufferGOOGLE(
     const VkImportBufferGOOGLE* 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_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->buffer, sizeof(uint32_t));
 }
 
@@ -13587,14 +10327,7 @@ void unmarshal_VkImportBufferGOOGLE(
     VkImportBufferGOOGLE* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint32_t*)&forUnmarshaling->buffer, sizeof(uint32_t));
 }
 
@@ -13603,13 +10336,7 @@ void marshal_VkImportPhysicalAddressGOOGLE(
     const VkImportPhysicalAddressGOOGLE* 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_extension_struct(vkStream, forMarshaling->pNext);
     vkStream->write((uint64_t*)&forMarshaling->physicalAddress, sizeof(uint64_t));
     vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
     vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
@@ -13622,14 +10349,7 @@ void unmarshal_VkImportPhysicalAddressGOOGLE(
     VkImportPhysicalAddressGOOGLE* forUnmarshaling)
 {
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    if (pNext_size)
-    {
-        uint64_t pNext_placeholder;
-        vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
-        unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
-    }
+    unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     vkStream->read((uint64_t*)&forUnmarshaling->physicalAddress, sizeof(uint64_t));
     vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
     vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
@@ -13648,10 +10368,31 @@ void unmarshal_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_free_memory_sync
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#endif
 void marshal_extension_struct(
     VulkanStreamGuest* vkStream,
     const void* structExtension)
 {
+    VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
+    size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(vkStream->getFeatureBits(), structExtension);
+    if (!currExtSize && structExtension)
+    {
+        // unknown struct extension; skip and call on its pNext field
+        marshal_extension_struct(vkStream, (void*)structAccess->pNext);
+        return;
+    }
+    else
+    {
+        // known or null extension struct
+        vkStream->putBe32(currExtSize);
+        if (!currExtSize)
+        {
+            // exit if this was a null extension struct (size == 0 in this branch)
+            return;
+        }
+    }
+    vkStream->write(structExtension, sizeof(VkStructureType));
     if (!structExtension)
     {
         return;
@@ -13965,6 +10706,13 @@ void marshal_extension_struct(
             break;
         }
 #endif
+#ifdef VK_KHR_shader_float16_int8
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        {
+            marshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
         {
@@ -14311,7 +11059,8 @@ void marshal_extension_struct(
 #endif
         default:
         {
-            return;
+            // fatal; the switch is only taken if the extension struct is known
+            abort();
         }
     }
 }
@@ -14320,6 +11069,27 @@ void unmarshal_extension_struct(
     VulkanStreamGuest* vkStream,
     void* structExtension_out)
 {
+    VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension_out);
+    size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(vkStream->getFeatureBits(), structExtension_out);
+    if (!currExtSize && structExtension_out)
+    {
+        // unknown struct extension; skip and call on its pNext field
+        unmarshal_extension_struct(vkStream, (void*)structAccess->pNext);
+        return;
+    }
+    else
+    {
+        // known or null extension struct
+        vkStream->getBe32();
+        if (!currExtSize)
+        {
+            // exit if this was a null extension struct (size == 0 in this branch)
+            return;
+        }
+    }
+    uint64_t pNext_placeholder;
+    vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
+    (void)pNext_placeholder;
     if (!structExtension_out)
     {
         return;
@@ -14633,6 +11403,13 @@ void unmarshal_extension_struct(
             break;
         }
 #endif
+#ifdef VK_KHR_shader_float16_int8
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        {
+            unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
         {
@@ -14979,7 +11756,8 @@ void unmarshal_extension_struct(
 #endif
         default:
         {
-            return;
+            // fatal; the switch is only taken if the extension struct is known
+            abort();
         }
     }
 }
@@ -16445,6 +13223,24 @@ const char* api_opcode_to_string(
             return "OP_vkFreeMemorySyncGOOGLE";
         }
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+        case OP_vkQueueHostSyncGOOGLE:
+        {
+            return "OP_vkQueueHostSyncGOOGLE";
+        }
+        case OP_vkQueueSubmitAsyncGOOGLE:
+        {
+            return "OP_vkQueueSubmitAsyncGOOGLE";
+        }
+        case OP_vkQueueWaitIdleAsyncGOOGLE:
+        {
+            return "OP_vkQueueWaitIdleAsyncGOOGLE";
+        }
+        case OP_vkQueueBindSparseAsyncGOOGLE:
+        {
+            return "OP_vkQueueBindSparseAsyncGOOGLE";
+        }
+#endif
         default:
         {
             return "OP_UNKNOWN_API_CALL";
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
index fce6adcf..df07272c 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.h
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -2334,6 +2334,16 @@ void unmarshal_VkPhysicalDevice8BitStorageFeaturesKHR(
     VkPhysicalDevice8BitStorageFeaturesKHR* forUnmarshaling);
 
 #endif
+#ifdef VK_KHR_shader_float16_int8
+void marshal_VkPhysicalDeviceShaderFloat16Int8Features(
+    VulkanStreamGuest* vkStream,
+    const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
+    VulkanStreamGuest* vkStream,
+    VkPhysicalDeviceShaderFloat16Int8Features* forUnmarshaling);
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void marshal_VkNativeBufferANDROID(
     VulkanStreamGuest* vkStream,
@@ -3408,6 +3418,12 @@ void unmarshal_VkImportPhysicalAddressGOOGLE(
 #ifdef VK_GOOGLE_free_memory_sync
 #define OP_vkFreeMemorySyncGOOGLE 20328
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#define OP_vkQueueHostSyncGOOGLE 20329
+#define OP_vkQueueSubmitAsyncGOOGLE 20330
+#define OP_vkQueueWaitIdleAsyncGOOGLE 20331
+#define OP_vkQueueBindSparseAsyncGOOGLE 20332
+#endif
 const char* api_opcode_to_string(
     const uint32_t opcode);
 
diff --git a/system/vulkan_enc/goldfish_vk_private_defs.h b/system/vulkan_enc/goldfish_vk_private_defs.h
index ab153798..dc4b7c64 100644
--- a/system/vulkan_enc/goldfish_vk_private_defs.h
+++ b/system/vulkan_enc/goldfish_vk_private_defs.h
@@ -504,6 +504,14 @@ typedef struct VkBufferCollectionPropertiesFUCHSIA {
 #define VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION 1
 #define VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME "VK_FUCHSIA_external_memory"
 
+typedef struct VkBufferConstraintsInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext;
+    const VkBufferCreateInfo* pBufferCreateInfo;
+    VkFormatFeatureFlags requiredFormatFeatures;
+    uint32_t minCount;
+} VkBufferConstraintsInfoFUCHSIA;
+
 typedef struct VkImportMemoryZirconHandleInfoFUCHSIA {
     VkStructureType                       sType;
     const void*                           pNext;
@@ -524,6 +532,8 @@ typedef struct VkMemoryGetZirconHandleInfoFUCHSIA {
     VkExternalMemoryHandleTypeFlagBits    handleType;
 } VkMemoryGetZirconHandleInfoFUCHSIA;
 
+#define VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA \
+    ((VkStructureType)1001004008)
 #define VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA \
     ((VkStructureType)1001005000)
 #define VK_STRUCTURE_TYPE_TEMP_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA \
@@ -560,9 +570,54 @@ typedef struct VkSemaphoreGetZirconHandleInfoFUCHSIA {
 // VulkanStream features
 #define VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT (1 << 0)
 #define VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT (1 << 1)
+#define VULKAN_STREAM_FEATURE_SHADER_FLOAT16_INT8_BIT (1 << 2)
 
 #define VK_YCBCR_CONVERSION_DO_NOTHING ((VkSamplerYcbcrConversion)0x1111111111111111)
 
+// Stuff we advertised but didn't define the structs for it yet because
+// we also needed to update our vulkan headers and xml
+
+#ifndef VK_VERSION_1_2
+
+typedef struct VkPhysicalDeviceShaderFloat16Int8Features {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderFloat16;
+    VkBool32           shaderInt8;
+} VkPhysicalDeviceShaderFloat16Int8Features;
+
+
+#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES \
+    ((VkStructureType)1000082000)
+
+#endif
+
+#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR \
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES
+
+#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR \
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES
+
+#ifndef VK_KHR_shader_float16_int8
+
+#define VK_KHR_shader_float16_int8 1
+#define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1
+#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
+typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
+typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR;
+
+#endif
+
+#define VK_GOOGLE_async_queue_submit 1
+
+typedef void (VKAPI_PTR *PFN_vkQueueHostSyncGOOGLE)(
+    VkQueue queue, uint32_t needHostSync, uint32_t sequenceNumber);
+typedef void (VKAPI_PTR *PFN_vkQueueSubmitAsyncGOOGLE)(
+    VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
+typedef void (VKAPI_PTR *PFN_vkQueueWaitIdleAsyncGOOGLE)(VkQueue queue);
+typedef void (VKAPI_PTR *PFN_vkQueueBindSparseAsyncGOOGLE)(
+    VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.cpp b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
index f4acb8e6..6fc3e46c 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
@@ -6245,6 +6245,32 @@ void transform_fromhost_VkPhysicalDevice8BitStorageFeaturesKHR(
 }
 
 #endif
+#ifdef VK_KHR_shader_float16_int8
+void transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features(
+    ResourceTracker* resourceTracker,
+    VkPhysicalDeviceShaderFloat16Int8Features* toTransform)
+{
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext)
+    {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features(
+    ResourceTracker* resourceTracker,
+    VkPhysicalDeviceShaderFloat16Int8Features* toTransform)
+{
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext)
+    {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void transform_tohost_VkNativeBufferANDROID(
     ResourceTracker* resourceTracker,
@@ -8975,6 +9001,8 @@ void transform_fromhost_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_free_memory_sync
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#endif
 void transform_tohost_extension_struct(
     ResourceTracker* resourceTracker,
     void* structExtension_out)
@@ -9297,6 +9325,13 @@ void transform_tohost_extension_struct(
             break;
         }
 #endif
+#ifdef VK_KHR_shader_float16_int8
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        {
+            transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
         {
@@ -9970,6 +10005,13 @@ void transform_fromhost_extension_struct(
             break;
         }
 #endif
+#ifdef VK_KHR_shader_float16_int8
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        {
+            transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
         {
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.h b/system/vulkan_enc/goldfish_vk_transform_guest.h
index da1f493b..b9699583 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.h
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.h
@@ -2085,6 +2085,16 @@ void transform_fromhost_VkPhysicalDevice8BitStorageFeaturesKHR(
     VkPhysicalDevice8BitStorageFeaturesKHR* toTransform);
 
 #endif
+#ifdef VK_KHR_shader_float16_int8
+void transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features(
+    ResourceTracker* resourceTracker,
+    VkPhysicalDeviceShaderFloat16Int8Features* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features(
+    ResourceTracker* resourceTracker,
+    VkPhysicalDeviceShaderFloat16Int8Features* toTransform);
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void transform_tohost_VkNativeBufferANDROID(
     ResourceTracker* resourceTracker,
@@ -3081,5 +3091,7 @@ void transform_fromhost_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_free_memory_sync
 #endif
+#ifdef VK_GOOGLE_async_queue_submit
+#endif
 
 } // namespace goldfish_vk