venus: update venus-protocol headers

This takes vn_protocol_driver_{structs,commands,calls}.h and split them
by Vulkan handle types.  This enables us to split up vn_device.c in the
following commits without slowing down compile time too much.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Acked-by: Erik Faye-Lund <erik.faye-lund@collabora.com>
Reviewed-by: Ryan Neph <ryanneph@google.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/10117>

diff --git a/src/virtio/venus-protocol/vn_protocol_driver.h b/src/virtio/venus-protocol/vn_protocol_driver.h
index 315a450..e2628ad 100644 (file)
--- a/src/virtio/venus-protocol/vn_protocol_driver.h
+++ b/src/virtio/venus-protocol/vn_protocol_driver.h
@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC
@@ -14,7 +14,32 @@
 #include "vn_protocol_driver_types.h"
 #include "vn_protocol_driver_handles.h"
 #include "vn_protocol_driver_structs.h"
-#include "vn_protocol_driver_commands.h"
-#include "vn_protocol_driver_calls.h"
+#include "vn_protocol_driver_transport.h"
+#include "vn_protocol_driver_instance.h"
+#include "vn_protocol_driver_device.h"
+#include "vn_protocol_driver_queue.h"
+#include "vn_protocol_driver_fence.h"
+#include "vn_protocol_driver_semaphore.h"
+#include "vn_protocol_driver_event.h"
+#include "vn_protocol_driver_device_memory.h"
+#include "vn_protocol_driver_image.h"
+#include "vn_protocol_driver_image_view.h"
+#include "vn_protocol_driver_sampler.h"
+#include "vn_protocol_driver_sampler_ycbcr_conversion.h"
+#include "vn_protocol_driver_buffer.h"
+#include "vn_protocol_driver_buffer_view.h"
+#include "vn_protocol_driver_descriptor_pool.h"
+#include "vn_protocol_driver_descriptor_set.h"
+#include "vn_protocol_driver_descriptor_set_layout.h"
+#include "vn_protocol_driver_descriptor_update_template.h"
+#include "vn_protocol_driver_render_pass.h"
+#include "vn_protocol_driver_framebuffer.h"
+#include "vn_protocol_driver_query_pool.h"
+#include "vn_protocol_driver_shader_module.h"
+#include "vn_protocol_driver_pipeline.h"
+#include "vn_protocol_driver_pipeline_layout.h"
+#include "vn_protocol_driver_pipeline_cache.h"
+#include "vn_protocol_driver_command_pool.h"
+#include "vn_protocol_driver_command_buffer.h"
 
 #endif /* VN_PROTOCOL_DRIVER_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_buffer.h b/src/virtio/venus-protocol/vn_protocol_driver_buffer.h
new file mode 100644 (file)
index 0000000..c96db23
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_buffer.h
@@ -0,0 +1,1390 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_BUFFER_H
+#define VN_PROTOCOL_DRIVER_BUFFER_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkExternalMemoryBufferCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkExternalMemoryBufferCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExternalMemoryBufferCreateInfo_self(const VkExternalMemoryBufferCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->handleTypes);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExternalMemoryBufferCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkExternalMemoryBufferCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExternalMemoryBufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExternalMemoryBufferCreateInfo_self(struct vn_cs_encoder *enc, const VkExternalMemoryBufferCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->handleTypes);
+}
+
+static inline void
+vn_encode_VkExternalMemoryBufferCreateInfo(struct vn_cs_encoder *enc, const VkExternalMemoryBufferCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO });
+    vn_encode_VkExternalMemoryBufferCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkExternalMemoryBufferCreateInfo_self(enc, val);
+}
+
+/* struct VkBufferOpaqueCaptureAddressCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_self(const VkBufferOpaqueCaptureAddressCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint64_t(&val->opaqueCaptureAddress);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferOpaqueCaptureAddressCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint64_t(enc, &val->opaqueCaptureAddress);
+}
+
+static inline void
+vn_encode_VkBufferOpaqueCaptureAddressCreateInfo(struct vn_cs_encoder *enc, const VkBufferOpaqueCaptureAddressCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO });
+    vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(enc, val);
+}
+
+/* struct VkBufferCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkBufferCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkBufferCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkExternalMemoryBufferCreateInfo_self((const VkExternalMemoryBufferCreateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkBufferCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_self((const VkBufferOpaqueCaptureAddressCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBufferCreateInfo_self(const VkBufferCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkDeviceSize(&val->size);
+    size += vn_sizeof_VkFlags(&val->usage);
+    size += vn_sizeof_VkSharingMode(&val->sharingMode);
+    size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
+    if (val->pQueueFamilyIndices) {
+        size += vn_sizeof_array_size(val->queueFamilyIndexCount);
+        size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBufferCreateInfo(const VkBufferCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBufferCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBufferCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkBufferCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkExternalMemoryBufferCreateInfo_self(enc, (const VkExternalMemoryBufferCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkBufferCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(enc, (const VkBufferOpaqueCaptureAddressCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBufferCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkDeviceSize(enc, &val->size);
+    vn_encode_VkFlags(enc, &val->usage);
+    vn_encode_VkSharingMode(enc, &val->sharingMode);
+    vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
+    if (val->pQueueFamilyIndices) {
+        vn_encode_array_size(enc, val->queueFamilyIndexCount);
+        vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkBufferCreateInfo(struct vn_cs_encoder *enc, const VkBufferCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO });
+    vn_encode_VkBufferCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkBufferCreateInfo_self(enc, val);
+}
+
+/* struct VkBindBufferMemoryDeviceGroupInfo chain */
+
+static inline size_t
+vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_self(const VkBindBufferMemoryDeviceGroupInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->deviceIndexCount);
+    if (val->pDeviceIndices) {
+        size += vn_sizeof_array_size(val->deviceIndexCount);
+        size += vn_sizeof_uint32_t_array(val->pDeviceIndices, val->deviceIndexCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBindBufferMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBindBufferMemoryDeviceGroupInfo_self(struct vn_cs_encoder *enc, const VkBindBufferMemoryDeviceGroupInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->deviceIndexCount);
+    if (val->pDeviceIndices) {
+        vn_encode_array_size(enc, val->deviceIndexCount);
+        vn_encode_uint32_t_array(enc, val->pDeviceIndices, val->deviceIndexCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkBindBufferMemoryDeviceGroupInfo(struct vn_cs_encoder *enc, const VkBindBufferMemoryDeviceGroupInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO });
+    vn_encode_VkBindBufferMemoryDeviceGroupInfo_pnext(enc, val->pNext);
+    vn_encode_VkBindBufferMemoryDeviceGroupInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkBindBufferMemoryDeviceGroupInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkBindBufferMemoryDeviceGroupInfo_self(struct vn_cs_decoder *dec, VkBindBufferMemoryDeviceGroupInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->deviceIndexCount);
+    if (vn_peek_array_size(dec)) {
+        const size_t array_size = vn_decode_array_size(dec, val->deviceIndexCount);
+        vn_decode_uint32_t_array(dec, (uint32_t *)val->pDeviceIndices, array_size);
+    } else {
+        vn_decode_array_size(dec, 0);
+        val->pDeviceIndices = NULL;
+    }
+}
+
+static inline void
+vn_decode_VkBindBufferMemoryDeviceGroupInfo(struct vn_cs_decoder *dec, VkBindBufferMemoryDeviceGroupInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkBindBufferMemoryDeviceGroupInfo_pnext(dec, val->pNext);
+    vn_decode_VkBindBufferMemoryDeviceGroupInfo_self(dec, val);
+}
+
+/* struct VkBindBufferMemoryInfo chain */
+
+static inline size_t
+vn_sizeof_VkBindBufferMemoryInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkBindBufferMemoryInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_self((const VkBindBufferMemoryDeviceGroupInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBindBufferMemoryInfo_self(const VkBindBufferMemoryInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBuffer(&val->buffer);
+    size += vn_sizeof_VkDeviceMemory(&val->memory);
+    size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBindBufferMemoryInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBindBufferMemoryInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBindBufferMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkBindBufferMemoryInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkBindBufferMemoryDeviceGroupInfo_self(enc, (const VkBindBufferMemoryDeviceGroupInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBindBufferMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindBufferMemoryInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBuffer(enc, &val->buffer);
+    vn_encode_VkDeviceMemory(enc, &val->memory);
+    vn_encode_VkDeviceSize(enc, &val->memoryOffset);
+}
+
+static inline void
+vn_encode_VkBindBufferMemoryInfo(struct vn_cs_encoder *enc, const VkBindBufferMemoryInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO });
+    vn_encode_VkBindBufferMemoryInfo_pnext(enc, val->pNext);
+    vn_encode_VkBindBufferMemoryInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkBindBufferMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return;
+
+    vn_decode_VkStructureType(dec, &stype);
+    while (true) {
+        assert(pnext);
+        if (pnext->sType == stype)
+            break;
+    }
+
+    switch ((int32_t)pnext->sType) {
+    case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+        vn_decode_VkBindBufferMemoryInfo_pnext(dec, pnext->pNext);
+        vn_decode_VkBindBufferMemoryDeviceGroupInfo_self(dec, (VkBindBufferMemoryDeviceGroupInfo *)pnext);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_decode_VkBindBufferMemoryInfo_self(struct vn_cs_decoder *dec, VkBindBufferMemoryInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBuffer(dec, &val->buffer);
+    vn_decode_VkDeviceMemory(dec, &val->memory);
+    vn_decode_VkDeviceSize(dec, &val->memoryOffset);
+}
+
+static inline void
+vn_decode_VkBindBufferMemoryInfo(struct vn_cs_decoder *dec, VkBindBufferMemoryInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkBindBufferMemoryInfo_pnext(dec, val->pNext);
+    vn_decode_VkBindBufferMemoryInfo_self(dec, val);
+}
+
+/* struct VkBufferMemoryRequirementsInfo2 chain */
+
+static inline size_t
+vn_sizeof_VkBufferMemoryRequirementsInfo2_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBufferMemoryRequirementsInfo2_self(const VkBufferMemoryRequirementsInfo2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBuffer(&val->buffer);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBufferMemoryRequirementsInfo2_pnext(val->pNext);
+    size += vn_sizeof_VkBufferMemoryRequirementsInfo2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBufferMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBufferMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkBufferMemoryRequirementsInfo2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBuffer(enc, &val->buffer);
+}
+
+static inline void
+vn_encode_VkBufferMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkBufferMemoryRequirementsInfo2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 });
+    vn_encode_VkBufferMemoryRequirementsInfo2_pnext(enc, val->pNext);
+    vn_encode_VkBufferMemoryRequirementsInfo2_self(enc, val);
+}
+
+/* struct VkBufferDeviceAddressInfo chain */
+
+static inline size_t
+vn_sizeof_VkBufferDeviceAddressInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBufferDeviceAddressInfo_self(const VkBufferDeviceAddressInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBuffer(&val->buffer);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBufferDeviceAddressInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBufferDeviceAddressInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBufferDeviceAddressInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBufferDeviceAddressInfo_self(struct vn_cs_encoder *enc, const VkBufferDeviceAddressInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBuffer(enc, &val->buffer);
+}
+
+static inline void
+vn_encode_VkBufferDeviceAddressInfo(struct vn_cs_encoder *enc, const VkBufferDeviceAddressInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO });
+    vn_encode_VkBufferDeviceAddressInfo_pnext(enc, val->pNext);
+    vn_encode_VkBufferDeviceAddressInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkBufferDeviceAddressInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkBufferDeviceAddressInfo_self(struct vn_cs_decoder *dec, VkBufferDeviceAddressInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBuffer(dec, &val->buffer);
+}
+
+static inline void
+vn_decode_VkBufferDeviceAddressInfo(struct vn_cs_decoder *dec, VkBufferDeviceAddressInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkBufferDeviceAddressInfo_pnext(dec, val->pNext);
+    vn_decode_VkBufferDeviceAddressInfo_self(dec, val);
+}
+
+static inline size_t vn_sizeof_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkBuffer(&buffer);
+    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
+    if (pMemoryRequirements)
+        cmd_size += vn_sizeof_VkMemoryRequirements_partial(pMemoryRequirements);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetBufferMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkBuffer(enc, &buffer);
+    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
+        vn_encode_VkMemoryRequirements_partial(enc, pMemoryRequirements);
+}
+
+static inline size_t vn_sizeof_vkGetBufferMemoryRequirements_reply(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip buffer */
+    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
+    if (pMemoryRequirements)
+        cmd_size += vn_sizeof_VkMemoryRequirements(pMemoryRequirements);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetBufferMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT);
+
+    /* skip device */
+    /* skip buffer */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkMemoryRequirements(dec, pMemoryRequirements);
+    } else {
+        pMemoryRequirements = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkBuffer(&buffer);
+    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
+    cmd_size += vn_sizeof_VkDeviceSize(&memoryOffset);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkBindBufferMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkBuffer(enc, &buffer);
+    vn_encode_VkDeviceMemory(enc, &memory);
+    vn_encode_VkDeviceSize(enc, &memoryOffset);
+}
+
+static inline size_t vn_sizeof_vkBindBufferMemory_reply(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip buffer */
+    /* skip memory */
+    /* skip memoryOffset */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkBindBufferMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkBindBufferMemory_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip buffer */
+    /* skip memory */
+    /* skip memoryOffset */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkBufferCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pBuffer);
+    if (pBuffer)
+        cmd_size += vn_sizeof_VkBuffer(pBuffer);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkBufferCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pBuffer))
+        vn_encode_VkBuffer(enc, pBuffer);
+}
+
+static inline size_t vn_sizeof_vkCreateBuffer_reply(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pBuffer);
+    if (pBuffer)
+        cmd_size += vn_sizeof_VkBuffer(pBuffer);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateBuffer_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateBuffer_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkBuffer(dec, pBuffer);
+    } else {
+        pBuffer = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkBuffer(&buffer);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkBuffer(enc, &buffer);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyBuffer_reply(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip buffer */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyBuffer_reply(struct vn_cs_decoder *dec, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyBuffer_EXT);
+
+    /* skip device */
+    /* skip buffer */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&bindInfoCount);
+    if (pBindInfos) {
+        cmd_size += vn_sizeof_array_size(bindInfoCount);
+        for (uint32_t i = 0; i < bindInfoCount; i++)
+            cmd_size += vn_sizeof_VkBindBufferMemoryInfo(&pBindInfos[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkBindBufferMemory2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &bindInfoCount);
+    if (pBindInfos) {
+        vn_encode_array_size(enc, bindInfoCount);
+        for (uint32_t i = 0; i < bindInfoCount; i++)
+            vn_encode_VkBindBufferMemoryInfo(enc, &pBindInfos[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkBindBufferMemory2_reply(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip bindInfoCount */
+    /* skip pBindInfos */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkBindBufferMemory2_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkBindBufferMemory2_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip bindInfoCount */
+    /* skip pBindInfos */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pInfo);
+    if (pInfo)
+        cmd_size += vn_sizeof_VkBufferMemoryRequirementsInfo2(pInfo);
+    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
+    if (pMemoryRequirements)
+        cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetBufferMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pInfo))
+        vn_encode_VkBufferMemoryRequirementsInfo2(enc, pInfo);
+    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
+        vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
+}
+
+static inline size_t vn_sizeof_vkGetBufferMemoryRequirements2_reply(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pInfo */
+    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
+    if (pMemoryRequirements)
+        cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetBufferMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT);
+
+    /* skip device */
+    /* skip pInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
+    } else {
+        pMemoryRequirements = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pInfo);
+    if (pInfo)
+        cmd_size += vn_sizeof_VkBufferDeviceAddressInfo(pInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetBufferOpaqueCaptureAddress(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pInfo))
+        vn_encode_VkBufferDeviceAddressInfo(enc, pInfo);
+}
+
+static inline size_t vn_sizeof_vkGetBufferOpaqueCaptureAddress_reply(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    uint64_t ret;
+    cmd_size += vn_sizeof_uint64_t(&ret);
+    /* skip device */
+    /* skip pInfo */
+
+    return cmd_size;
+}
+
+static inline uint64_t vn_decode_vkGetBufferOpaqueCaptureAddress_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT);
+
+    uint64_t ret;
+    vn_decode_uint64_t(dec, &ret);
+    /* skip device */
+    /* skip pInfo */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pInfo);
+    if (pInfo)
+        cmd_size += vn_sizeof_VkBufferDeviceAddressInfo(pInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetBufferDeviceAddress(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pInfo))
+        vn_encode_VkBufferDeviceAddressInfo(enc, pInfo);
+}
+
+static inline size_t vn_sizeof_vkGetBufferDeviceAddress_reply(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkDeviceAddress ret;
+    cmd_size += vn_sizeof_VkDeviceAddress(&ret);
+    /* skip device */
+    /* skip pInfo */
+
+    return cmd_size;
+}
+
+static inline VkDeviceAddress vn_decode_vkGetBufferDeviceAddress_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT);
+
+    VkDeviceAddress ret;
+    vn_decode_VkDeviceAddress(dec, &ret);
+    /* skip device */
+    /* skip pInfo */
+
+    return ret;
+}
+
+static inline void vn_submit_vkGetBufferMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetBufferMemoryRequirements(&submit->command, cmd_flags, device, buffer, pMemoryRequirements);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferMemoryRequirements_reply(device, buffer, pMemoryRequirements) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkBindBufferMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkBindBufferMemory(device, buffer, memory, memoryOffset);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkBindBufferMemory(&submit->command, cmd_flags, device, buffer, memory, memoryOffset);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindBufferMemory_reply(device, buffer, memory, memoryOffset) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCreateBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateBuffer(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pBuffer);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBuffer_reply(device, pCreateInfo, pAllocator, pBuffer) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyBuffer(device, buffer, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyBuffer(&submit->command, cmd_flags, device, buffer, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBuffer_reply(device, buffer, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkBindBufferMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkBindBufferMemory2(&submit->command, cmd_flags, device, bindInfoCount, pBindInfos);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindBufferMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetBufferMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetBufferMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pMemoryRequirements);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetBufferOpaqueCaptureAddress(device, pInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetBufferOpaqueCaptureAddress(&submit->command, cmd_flags, device, pInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferOpaqueCaptureAddress_reply(device, pInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetBufferDeviceAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetBufferDeviceAddress(device, pInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetBufferDeviceAddress(&submit->command, cmd_flags, device, pInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferDeviceAddress_reply(device, pInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_call_vkGetBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetBufferMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, pMemoryRequirements, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetBufferMemoryRequirements_reply(&submit.reply, device, buffer, pMemoryRequirements);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetBufferMemoryRequirements(vn_instance, 0, device, buffer, pMemoryRequirements, &submit);
+}
+
+static inline VkResult vn_call_vkBindBufferMemory(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkBindBufferMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, memory, memoryOffset, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkBindBufferMemory_reply(&submit.reply, device, buffer, memory, memoryOffset);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkBindBufferMemory(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkBindBufferMemory(vn_instance, 0, device, buffer, memory, memoryOffset, &submit);
+}
+
+static inline VkResult vn_call_vkCreateBuffer(struct vn_instance *vn_instance, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pBuffer, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateBuffer_reply(&submit.reply, device, pCreateInfo, pAllocator, pBuffer);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateBuffer(struct vn_instance *vn_instance, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateBuffer(vn_instance, 0, device, pCreateInfo, pAllocator, pBuffer, &submit);
+}
+
+static inline void vn_call_vkDestroyBuffer(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyBuffer_reply(&submit.reply, device, buffer, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyBuffer(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyBuffer(vn_instance, 0, device, buffer, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkBindBufferMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkBindBufferMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkBindBufferMemory2_reply(&submit.reply, device, bindInfoCount, pBindInfos);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkBindBufferMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkBindBufferMemory2(vn_instance, 0, device, bindInfoCount, pBindInfos, &submit);
+}
+
+static inline void vn_call_vkGetBufferMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetBufferMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetBufferMemoryRequirements2_reply(&submit.reply, device, pInfo, pMemoryRequirements);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetBufferMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetBufferMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
+}
+
+static inline uint64_t vn_call_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetBufferOpaqueCaptureAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit);
+    if (submit.reply_bo) {
+        const uint64_t ret = vn_decode_vkGetBufferOpaqueCaptureAddress_reply(&submit.reply, device, pInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetBufferOpaqueCaptureAddress(vn_instance, 0, device, pInfo, &submit);
+}
+
+static inline VkDeviceAddress vn_call_vkGetBufferDeviceAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetBufferDeviceAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit);
+    if (submit.reply_bo) {
+        const VkDeviceAddress ret = vn_decode_vkGetBufferDeviceAddress_reply(&submit.reply, device, pInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetBufferDeviceAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetBufferDeviceAddress(vn_instance, 0, device, pInfo, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_BUFFER_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_buffer_view.h b/src/virtio/venus-protocol/vn_protocol_driver_buffer_view.h
new file mode 100644 (file)
index 0000000..bcf46a3
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_buffer_view.h
@@ -0,0 +1,276 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_BUFFER_VIEW_H
+#define VN_PROTOCOL_DRIVER_BUFFER_VIEW_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkBufferViewCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkBufferViewCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBufferViewCreateInfo_self(const VkBufferViewCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkBuffer(&val->buffer);
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkDeviceSize(&val->offset);
+    size += vn_sizeof_VkDeviceSize(&val->range);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBufferViewCreateInfo(const VkBufferViewCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBufferViewCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBufferViewCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBufferViewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBufferViewCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferViewCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkBuffer(enc, &val->buffer);
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkDeviceSize(enc, &val->offset);
+    vn_encode_VkDeviceSize(enc, &val->range);
+}
+
+static inline void
+vn_encode_VkBufferViewCreateInfo(struct vn_cs_encoder *enc, const VkBufferViewCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO });
+    vn_encode_VkBufferViewCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkBufferViewCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkBufferViewCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pView);
+    if (pView)
+        cmd_size += vn_sizeof_VkBufferView(pView);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateBufferView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkBufferViewCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pView))
+        vn_encode_VkBufferView(enc, pView);
+}
+
+static inline size_t vn_sizeof_vkCreateBufferView_reply(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pView);
+    if (pView)
+        cmd_size += vn_sizeof_VkBufferView(pView);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateBufferView_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateBufferView_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkBufferView(dec, pView);
+    } else {
+        pView = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkBufferView(&bufferView);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyBufferView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkBufferView(enc, &bufferView);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyBufferView_reply(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip bufferView */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyBufferView_reply(struct vn_cs_decoder *dec, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyBufferView_EXT);
+
+    /* skip device */
+    /* skip bufferView */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateBufferView(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pView);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBufferView_reply(device, pCreateInfo, pAllocator, pView) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyBufferView(device, bufferView, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyBufferView(&submit->command, cmd_flags, device, bufferView, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBufferView_reply(device, bufferView, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateBufferView_reply(&submit.reply, device, pCreateInfo, pAllocator, pView);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateBufferView(vn_instance, 0, device, pCreateInfo, pAllocator, pView, &submit);
+}
+
+static inline void vn_call_vkDestroyBufferView(struct vn_instance *vn_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bufferView, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyBufferView_reply(&submit.reply, device, bufferView, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyBufferView(struct vn_instance *vn_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyBufferView(vn_instance, 0, device, bufferView, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_BUFFER_VIEW_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_calls.h b/src/virtio/venus-protocol/vn_protocol_driver_calls.h
deleted file mode 100644 (file)
index 536bb5e..0000000
--- a/src/virtio/venus-protocol/vn_protocol_driver_calls.h
+++ /dev/null
@@ -1,7176 +0,0 @@
-/* This file is generated by venus-protocol git-72189394. */
-
-/*
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef VN_PROTOCOL_DRIVER_CALLS_H
-#define VN_PROTOCOL_DRIVER_CALLS_H
-
-#include "vn_protocol_driver_commands.h"
-#include "vn_device.h"
-
-#define VN_SUBMIT_LOCAL_CMD_SIZE 256
-
-static inline void vn_submit_vkCreateInstance(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateInstance(pCreateInfo, pAllocator, pInstance);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateInstance(&submit->command, cmd_flags, pCreateInfo, pAllocator, pInstance);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateInstance_reply(pCreateInfo, pAllocator, pInstance) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyInstance(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyInstance(instance, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyInstance(&submit->command, cmd_flags, instance, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyInstance_reply(instance, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkEnumeratePhysicalDevices(&submit->command, cmd_flags, instance, pPhysicalDeviceCount, pPhysicalDevices);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDevices_reply(instance, pPhysicalDeviceCount, pPhysicalDevices) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceProperties(&submit->command, cmd_flags, physicalDevice, pProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties_reply(physicalDevice, pProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(&submit->command, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceMemoryProperties(&submit->command, cmd_flags, physicalDevice, pMemoryProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(physicalDevice, pMemoryProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceFeatures(&submit->command, cmd_flags, physicalDevice, pFeatures);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures_reply(physicalDevice, pFeatures) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceFormatProperties(&submit->command, cmd_flags, physicalDevice, format, pFormatProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(physicalDevice, format, pFormatProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceImageFormatProperties(&submit->command, cmd_flags, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateDevice(&submit->command, cmd_flags, physicalDevice, pCreateInfo, pAllocator, pDevice);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDevice_reply(physicalDevice, pCreateInfo, pAllocator, pDevice) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyDevice(device, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyDevice(&submit->command, cmd_flags, device, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDevice_reply(device, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t* pApiVersion, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkEnumerateInstanceVersion(pApiVersion);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkEnumerateInstanceVersion(&submit->command, cmd_flags, pApiVersion);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceVersion_reply(pApiVersion) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkEnumerateInstanceLayerProperties(&submit->command, cmd_flags, pPropertyCount, pProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceLayerProperties_reply(pPropertyCount, pProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkEnumerateInstanceExtensionProperties(&submit->command, cmd_flags, pLayerName, pPropertyCount, pProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceExtensionProperties_reply(pLayerName, pPropertyCount, pProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkEnumerateDeviceLayerProperties(&submit->command, cmd_flags, physicalDevice, pPropertyCount, pProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceLayerProperties_reply(physicalDevice, pPropertyCount, pProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkEnumerateDeviceExtensionProperties(&submit->command, cmd_flags, physicalDevice, pLayerName, pPropertyCount, pProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(physicalDevice, pLayerName, pPropertyCount, pProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetDeviceQueue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetDeviceQueue(&submit->command, cmd_flags, device, queueFamilyIndex, queueIndex, pQueue);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue_reply(device, queueFamilyIndex, queueIndex, pQueue) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkQueueSubmit(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkQueueSubmit(queue, submitCount, pSubmits, fence);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkQueueSubmit(&submit->command, cmd_flags, queue, submitCount, pSubmits, fence);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueSubmit_reply(queue, submitCount, pSubmits, fence) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkQueueWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkQueueWaitIdle(queue);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkQueueWaitIdle(&submit->command, cmd_flags, queue);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueWaitIdle_reply(queue) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDeviceWaitIdle(device);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDeviceWaitIdle(&submit->command, cmd_flags, device);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDeviceWaitIdle_reply(device) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkAllocateMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkAllocateMemory(&submit->command, cmd_flags, device, pAllocateInfo, pAllocator, pMemory);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateMemory_reply(device, pAllocateInfo, pAllocator, pMemory) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkFreeMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkFreeMemory(device, memory, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkFreeMemory(&submit->command, cmd_flags, device, memory, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeMemory_reply(device, memory, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkUnmapMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkUnmapMemory(device, memory);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkUnmapMemory(&submit->command, cmd_flags, device, memory);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUnmapMemory_reply(device, memory) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkFlushMappedMemoryRanges(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkFlushMappedMemoryRanges(&submit->command, cmd_flags, device, memoryRangeCount, pMemoryRanges);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFlushMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkInvalidateMappedMemoryRanges(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkInvalidateMappedMemoryRanges(&submit->command, cmd_flags, device, memoryRangeCount, pMemoryRanges);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkInvalidateMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetDeviceMemoryCommitment(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetDeviceMemoryCommitment(&submit->command, cmd_flags, device, memory, pCommittedMemoryInBytes);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryCommitment_reply(device, memory, pCommittedMemoryInBytes) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetBufferMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetBufferMemoryRequirements(&submit->command, cmd_flags, device, buffer, pMemoryRequirements);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferMemoryRequirements_reply(device, buffer, pMemoryRequirements) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkBindBufferMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkBindBufferMemory(device, buffer, memory, memoryOffset);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkBindBufferMemory(&submit->command, cmd_flags, device, buffer, memory, memoryOffset);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindBufferMemory_reply(device, buffer, memory, memoryOffset) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetImageMemoryRequirements(&submit->command, cmd_flags, device, image, pMemoryRequirements);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements_reply(device, image, pMemoryRequirements) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkBindImageMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkBindImageMemory(device, image, memory, memoryOffset);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkBindImageMemory(&submit->command, cmd_flags, device, image, memory, memoryOffset);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory_reply(device, image, memory, memoryOffset) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetImageSparseMemoryRequirements(&submit->command, cmd_flags, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements_reply(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(&submit->command, cmd_flags, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkQueueBindSparse(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkQueueBindSparse(&submit->command, cmd_flags, queue, bindInfoCount, pBindInfo, fence);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueBindSparse_reply(queue, bindInfoCount, pBindInfo, fence) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateFence(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateFence(device, pCreateInfo, pAllocator, pFence);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateFence(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pFence);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFence_reply(device, pCreateInfo, pAllocator, pFence) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyFence(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyFence(device, fence, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyFence(&submit->command, cmd_flags, device, fence, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFence_reply(device, fence, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkResetFences(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkResetFences(device, fenceCount, pFences);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkResetFences(&submit->command, cmd_flags, device, fenceCount, pFences);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetFences_reply(device, fenceCount, pFences) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetFenceStatus(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetFenceStatus(device, fence);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetFenceStatus(&submit->command, cmd_flags, device, fence);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetFenceStatus_reply(device, fence) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkWaitForFences(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkWaitForFences(&submit->command, cmd_flags, device, fenceCount, pFences, waitAll, timeout);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitForFences_reply(device, fenceCount, pFences, waitAll, timeout) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateSemaphore(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSemaphore);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSemaphore_reply(device, pCreateInfo, pAllocator, pSemaphore) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroySemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroySemaphore(device, semaphore, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroySemaphore(&submit->command, cmd_flags, device, semaphore, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySemaphore_reply(device, semaphore, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateEvent(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pEvent);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateEvent_reply(device, pCreateInfo, pAllocator, pEvent) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyEvent(device, event, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyEvent(&submit->command, cmd_flags, device, event, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyEvent_reply(device, event, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetEventStatus(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetEventStatus(device, event);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetEventStatus(&submit->command, cmd_flags, device, event);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetEventStatus_reply(device, event) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkSetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkSetEvent(device, event);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkSetEvent(&submit->command, cmd_flags, device, event);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetEvent_reply(device, event) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkResetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkResetEvent(device, event);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkResetEvent(&submit->command, cmd_flags, device, event);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetEvent_reply(device, event) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateQueryPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pQueryPool);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateQueryPool_reply(device, pCreateInfo, pAllocator, pQueryPool) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyQueryPool(device, queryPool, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyQueryPool(&submit->command, cmd_flags, device, queryPool, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyQueryPool_reply(device, queryPool, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetQueryPoolResults(&submit->command, cmd_flags, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetQueryPoolResults_reply(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkResetQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkResetQueryPool(device, queryPool, firstQuery, queryCount);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkResetQueryPool(&submit->command, cmd_flags, device, queryPool, firstQuery, queryCount);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetQueryPool_reply(device, queryPool, firstQuery, queryCount) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateBuffer(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pBuffer);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBuffer_reply(device, pCreateInfo, pAllocator, pBuffer) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyBuffer(device, buffer, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyBuffer(&submit->command, cmd_flags, device, buffer, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBuffer_reply(device, buffer, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateBufferView(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pView);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBufferView_reply(device, pCreateInfo, pAllocator, pView) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyBufferView(device, bufferView, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyBufferView(&submit->command, cmd_flags, device, bufferView, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBufferView_reply(device, bufferView, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateImage(device, pCreateInfo, pAllocator, pImage);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateImage(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pImage);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImage_reply(device, pCreateInfo, pAllocator, pImage) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyImage(device, image, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyImage(&submit->command, cmd_flags, device, image, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImage_reply(device, image, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetImageSubresourceLayout(&submit->command, cmd_flags, device, image, pSubresource, pLayout);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSubresourceLayout_reply(device, image, pSubresource, pLayout) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateImageView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateImageView(device, pCreateInfo, pAllocator, pView);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateImageView(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pView);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImageView_reply(device, pCreateInfo, pAllocator, pView) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyImageView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyImageView(device, imageView, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyImageView(&submit->command, cmd_flags, device, imageView, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImageView_reply(device, imageView, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateShaderModule(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateShaderModule(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pShaderModule);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateShaderModule_reply(device, pCreateInfo, pAllocator, pShaderModule) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyShaderModule(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyShaderModule(device, shaderModule, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyShaderModule(&submit->command, cmd_flags, device, shaderModule, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyShaderModule_reply(device, shaderModule, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreatePipelineCache(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreatePipelineCache(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pPipelineCache);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineCache_reply(device, pCreateInfo, pAllocator, pPipelineCache) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyPipelineCache(device, pipelineCache, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyPipelineCache(&submit->command, cmd_flags, device, pipelineCache, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineCache_reply(device, pipelineCache, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPipelineCacheData(&submit->command, cmd_flags, device, pipelineCache, pDataSize, pData);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPipelineCacheData_reply(device, pipelineCache, pDataSize, pData) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkMergePipelineCaches(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkMergePipelineCaches(&submit->command, cmd_flags, device, dstCache, srcCacheCount, pSrcCaches);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkMergePipelineCaches_reply(device, dstCache, srcCacheCount, pSrcCaches) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateGraphicsPipelines(&submit->command, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateGraphicsPipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateComputePipelines(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateComputePipelines(&submit->command, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateComputePipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyPipeline(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyPipeline(device, pipeline, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyPipeline(&submit->command, cmd_flags, device, pipeline, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipeline_reply(device, pipeline, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreatePipelineLayout(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pPipelineLayout);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineLayout_reply(device, pCreateInfo, pAllocator, pPipelineLayout) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyPipelineLayout(&submit->command, cmd_flags, device, pipelineLayout, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineLayout_reply(device, pipelineLayout, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateSampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateSampler(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSampler);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSampler_reply(device, pCreateInfo, pAllocator, pSampler) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroySampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroySampler(device, sampler, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroySampler(&submit->command, cmd_flags, device, sampler, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySampler_reply(device, sampler, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateDescriptorSetLayout(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSetLayout);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorSetLayout_reply(device, pCreateInfo, pAllocator, pSetLayout) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyDescriptorSetLayout(&submit->command, cmd_flags, device, descriptorSetLayout, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorSetLayout_reply(device, descriptorSetLayout, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateDescriptorPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorPool);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorPool_reply(device, pCreateInfo, pAllocator, pDescriptorPool) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyDescriptorPool(&submit->command, cmd_flags, device, descriptorPool, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorPool_reply(device, descriptorPool, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkResetDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkResetDescriptorPool(device, descriptorPool, flags);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkResetDescriptorPool(&submit->command, cmd_flags, device, descriptorPool, flags);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetDescriptorPool_reply(device, descriptorPool, flags) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkAllocateDescriptorSets(&submit->command, cmd_flags, device, pAllocateInfo, pDescriptorSets);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateDescriptorSets_reply(device, pAllocateInfo, pDescriptorSets) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkFreeDescriptorSets(&submit->command, cmd_flags, device, descriptorPool, descriptorSetCount, pDescriptorSets);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeDescriptorSets_reply(device, descriptorPool, descriptorSetCount, pDescriptorSets) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkUpdateDescriptorSets(&submit->command, cmd_flags, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUpdateDescriptorSets_reply(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateFramebuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateFramebuffer(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pFramebuffer);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFramebuffer_reply(device, pCreateInfo, pAllocator, pFramebuffer) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyFramebuffer(device, framebuffer, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyFramebuffer(&submit->command, cmd_flags, device, framebuffer, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFramebuffer_reply(device, framebuffer, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateRenderPass(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyRenderPass(device, renderPass, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyRenderPass(&submit->command, cmd_flags, device, renderPass, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRenderPass_reply(device, renderPass, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetRenderAreaGranularity(device, renderPass, pGranularity);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetRenderAreaGranularity(&submit->command, cmd_flags, device, renderPass, pGranularity);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetRenderAreaGranularity_reply(device, renderPass, pGranularity) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateCommandPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pCommandPool);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateCommandPool_reply(device, pCreateInfo, pAllocator, pCommandPool) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyCommandPool(device, commandPool, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyCommandPool(&submit->command, cmd_flags, device, commandPool, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyCommandPool_reply(device, commandPool, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkResetCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkResetCommandPool(device, commandPool, flags);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkResetCommandPool(&submit->command, cmd_flags, device, commandPool, flags);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetCommandPool_reply(device, commandPool, flags) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkAllocateCommandBuffers(&submit->command, cmd_flags, device, pAllocateInfo, pCommandBuffers);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateCommandBuffers_reply(device, pAllocateInfo, pCommandBuffers) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkFreeCommandBuffers(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkFreeCommandBuffers(&submit->command, cmd_flags, device, commandPool, commandBufferCount, pCommandBuffers);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeCommandBuffers_reply(device, commandPool, commandBufferCount, pCommandBuffers) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkBeginCommandBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkBeginCommandBuffer(commandBuffer, pBeginInfo);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkBeginCommandBuffer(&submit->command, cmd_flags, commandBuffer, pBeginInfo);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBeginCommandBuffer_reply(commandBuffer, pBeginInfo) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkEndCommandBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkEndCommandBuffer(commandBuffer);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkEndCommandBuffer(&submit->command, cmd_flags, commandBuffer);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEndCommandBuffer_reply(commandBuffer) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkResetCommandBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkResetCommandBuffer(commandBuffer, flags);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkResetCommandBuffer(&submit->command, cmd_flags, commandBuffer, flags);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetCommandBuffer_reply(commandBuffer, flags) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBindPipeline(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBindPipeline(&submit->command, cmd_flags, commandBuffer, pipelineBindPoint, pipeline);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindPipeline_reply(commandBuffer, pipelineBindPoint, pipeline) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetViewport(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetViewport(&submit->command, cmd_flags, commandBuffer, firstViewport, viewportCount, pViewports);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetViewport_reply(commandBuffer, firstViewport, viewportCount, pViewports) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetScissor(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetScissor(&submit->command, cmd_flags, commandBuffer, firstScissor, scissorCount, pScissors);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetScissor_reply(commandBuffer, firstScissor, scissorCount, pScissors) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetLineWidth(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float lineWidth, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetLineWidth(commandBuffer, lineWidth);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetLineWidth(&submit->command, cmd_flags, commandBuffer, lineWidth);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetLineWidth_reply(commandBuffer, lineWidth) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetDepthBias(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetDepthBias(&submit->command, cmd_flags, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthBias_reply(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetBlendConstants(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const float blendConstants[4], struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetBlendConstants(commandBuffer, blendConstants);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetBlendConstants(&submit->command, cmd_flags, commandBuffer, blendConstants);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetBlendConstants_reply(commandBuffer, blendConstants) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetDepthBounds(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetDepthBounds(&submit->command, cmd_flags, commandBuffer, minDepthBounds, maxDepthBounds);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthBounds_reply(commandBuffer, minDepthBounds, maxDepthBounds) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetStencilCompareMask(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetStencilCompareMask(&submit->command, cmd_flags, commandBuffer, faceMask, compareMask);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilCompareMask_reply(commandBuffer, faceMask, compareMask) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetStencilWriteMask(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetStencilWriteMask(&submit->command, cmd_flags, commandBuffer, faceMask, writeMask);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilWriteMask_reply(commandBuffer, faceMask, writeMask) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetStencilReference(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetStencilReference(commandBuffer, faceMask, reference);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetStencilReference(&submit->command, cmd_flags, commandBuffer, faceMask, reference);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilReference_reply(commandBuffer, faceMask, reference) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBindDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBindDescriptorSets(&submit->command, cmd_flags, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindDescriptorSets_reply(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBindIndexBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBindIndexBuffer(&submit->command, cmd_flags, commandBuffer, buffer, offset, indexType);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindIndexBuffer_reply(commandBuffer, buffer, offset, indexType) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBindVertexBuffers(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBindVertexBuffers(&submit->command, cmd_flags, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindVertexBuffers_reply(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdDraw(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdDraw(&submit->command, cmd_flags, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDraw_reply(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdDrawIndexed(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdDrawIndexed(&submit->command, cmd_flags, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndexed_reply(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdDrawIndirect(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdDrawIndirect(&submit->command, cmd_flags, commandBuffer, buffer, offset, drawCount, stride);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndirect_reply(commandBuffer, buffer, offset, drawCount, stride) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdDrawIndexedIndirect(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdDrawIndexedIndirect(&submit->command, cmd_flags, commandBuffer, buffer, offset, drawCount, stride);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndexedIndirect_reply(commandBuffer, buffer, offset, drawCount, stride) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdDispatch(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdDispatch(&submit->command, cmd_flags, commandBuffer, groupCountX, groupCountY, groupCountZ);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDispatch_reply(commandBuffer, groupCountX, groupCountY, groupCountZ) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdDispatchIndirect(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdDispatchIndirect(commandBuffer, buffer, offset);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdDispatchIndirect(&submit->command, cmd_flags, commandBuffer, buffer, offset);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDispatchIndirect_reply(commandBuffer, buffer, offset) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdCopyBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdCopyBuffer(&submit->command, cmd_flags, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyBuffer_reply(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdCopyImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdCopyImage(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyImage_reply(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBlitImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBlitImage(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBlitImage_reply(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdCopyBufferToImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdCopyBufferToImage(&submit->command, cmd_flags, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyBufferToImage_reply(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdCopyImageToBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdCopyImageToBuffer(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyImageToBuffer_reply(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdUpdateBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdUpdateBuffer(&submit->command, cmd_flags, commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdUpdateBuffer_reply(commandBuffer, dstBuffer, dstOffset, dataSize, pData) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdFillBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdFillBuffer(&submit->command, cmd_flags, commandBuffer, dstBuffer, dstOffset, size, data);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdFillBuffer_reply(commandBuffer, dstBuffer, dstOffset, size, data) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdClearColorImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdClearColorImage(&submit->command, cmd_flags, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdClearColorImage_reply(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdClearDepthStencilImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdClearDepthStencilImage(&submit->command, cmd_flags, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdClearDepthStencilImage_reply(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdClearAttachments(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdClearAttachments(&submit->command, cmd_flags, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdClearAttachments_reply(commandBuffer, attachmentCount, pAttachments, rectCount, pRects) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdResolveImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdResolveImage(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResolveImage_reply(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetEvent(commandBuffer, event, stageMask);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetEvent(&submit->command, cmd_flags, commandBuffer, event, stageMask);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetEvent_reply(commandBuffer, event, stageMask) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdResetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdResetEvent(commandBuffer, event, stageMask);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdResetEvent(&submit->command, cmd_flags, commandBuffer, event, stageMask);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResetEvent_reply(commandBuffer, event, stageMask) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdWaitEvents(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdWaitEvents(&submit->command, cmd_flags, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdWaitEvents_reply(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdPipelineBarrier(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdPipelineBarrier(&submit->command, cmd_flags, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdPipelineBarrier_reply(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBeginQuery(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBeginQuery(&submit->command, cmd_flags, commandBuffer, queryPool, query, flags);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginQuery_reply(commandBuffer, queryPool, query, flags) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdEndQuery(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdEndQuery(commandBuffer, queryPool, query);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdEndQuery(&submit->command, cmd_flags, commandBuffer, queryPool, query);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndQuery_reply(commandBuffer, queryPool, query) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdResetQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdResetQueryPool(&submit->command, cmd_flags, commandBuffer, queryPool, firstQuery, queryCount);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResetQueryPool_reply(commandBuffer, queryPool, firstQuery, queryCount) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdWriteTimestamp(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdWriteTimestamp(&submit->command, cmd_flags, commandBuffer, pipelineStage, queryPool, query);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdWriteTimestamp_reply(commandBuffer, pipelineStage, queryPool, query) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdCopyQueryPoolResults(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdCopyQueryPoolResults(&submit->command, cmd_flags, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyQueryPoolResults_reply(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdPushConstants(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdPushConstants(&submit->command, cmd_flags, commandBuffer, layout, stageFlags, offset, size, pValues);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdPushConstants_reply(commandBuffer, layout, stageFlags, offset, size, pValues) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBeginRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBeginRenderPass(&submit->command, cmd_flags, commandBuffer, pRenderPassBegin, contents);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginRenderPass_reply(commandBuffer, pRenderPassBegin, contents) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdNextSubpass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkSubpassContents contents, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdNextSubpass(commandBuffer, contents);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdNextSubpass(&submit->command, cmd_flags, commandBuffer, contents);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdNextSubpass_reply(commandBuffer, contents) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdEndRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdEndRenderPass(commandBuffer);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdEndRenderPass(&submit->command, cmd_flags, commandBuffer);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndRenderPass_reply(commandBuffer) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdExecuteCommands(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdExecuteCommands(&submit->command, cmd_flags, commandBuffer, commandBufferCount, pCommandBuffers);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdExecuteCommands_reply(commandBuffer, commandBufferCount, pCommandBuffers) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceFeatures2(&submit->command, cmd_flags, physicalDevice, pFeatures);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(physicalDevice, pFeatures) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceProperties2(&submit->command, cmd_flags, physicalDevice, pProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties2_reply(physicalDevice, pProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceFormatProperties2(&submit->command, cmd_flags, physicalDevice, format, pFormatProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(physicalDevice, format, pFormatProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceImageFormatProperties2(&submit->command, cmd_flags, physicalDevice, pImageFormatInfo, pImageFormatProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(physicalDevice, pImageFormatInfo, pImageFormatProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(&submit->command, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceMemoryProperties2(&submit->command, cmd_flags, physicalDevice, pMemoryProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(physicalDevice, pMemoryProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(&submit->command, cmd_flags, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(physicalDevice, pFormatInfo, pPropertyCount, pProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkTrimCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkTrimCommandPool(device, commandPool, flags);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkTrimCommandPool(&submit->command, cmd_flags, device, commandPool, flags);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkTrimCommandPool_reply(device, commandPool, flags) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceExternalBufferProperties(&submit->command, cmd_flags, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(&submit->command, cmd_flags, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetPhysicalDeviceExternalFenceProperties(&submit->command, cmd_flags, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkEnumeratePhysicalDeviceGroups(&submit->command, cmd_flags, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetDeviceGroupPeerMemoryFeatures(&submit->command, cmd_flags, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkBindBufferMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkBindBufferMemory2(&submit->command, cmd_flags, device, bindInfoCount, pBindInfos);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindBufferMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkBindImageMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkBindImageMemory2(device, bindInfoCount, pBindInfos);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkBindImageMemory2(&submit->command, cmd_flags, device, bindInfoCount, pBindInfos);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdSetDeviceMask(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t deviceMask, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdSetDeviceMask(commandBuffer, deviceMask);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdSetDeviceMask(&submit->command, cmd_flags, commandBuffer, deviceMask);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDeviceMask_reply(commandBuffer, deviceMask) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdDispatchBase(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdDispatchBase(&submit->command, cmd_flags, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDispatchBase_reply(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateDescriptorUpdateTemplate(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorUpdateTemplate_reply(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyDescriptorUpdateTemplate(&submit->command, cmd_flags, device, descriptorUpdateTemplate, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorUpdateTemplate_reply(device, descriptorUpdateTemplate, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetBufferMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetBufferMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pMemoryRequirements);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetImageMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pMemoryRequirements);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetImageSparseMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateSamplerYcbcrConversion(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pYcbcrConversion);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSamplerYcbcrConversion_reply(device, pCreateInfo, pAllocator, pYcbcrConversion) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroySamplerYcbcrConversion(&submit->command, cmd_flags, device, ycbcrConversion, pAllocator);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySamplerYcbcrConversion_reply(device, ycbcrConversion, pAllocator) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetDeviceQueue2(device, pQueueInfo, pQueue);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetDeviceQueue2(&submit->command, cmd_flags, device, pQueueInfo, pQueue);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue2_reply(device, pQueueInfo, pQueue) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetDescriptorSetLayoutSupport(&submit->command, cmd_flags, device, pCreateInfo, pSupport);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDescriptorSetLayoutSupport_reply(device, pCreateInfo, pSupport) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateRenderPass2(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass2_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBeginRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBeginRenderPass2(&submit->command, cmd_flags, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginRenderPass2_reply(commandBuffer, pRenderPassBegin, pSubpassBeginInfo) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdNextSubpass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdNextSubpass2(&submit->command, cmd_flags, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdNextSubpass2_reply(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdEndRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdEndRenderPass2(&submit->command, cmd_flags, commandBuffer, pSubpassEndInfo);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndRenderPass2_reply(commandBuffer, pSubpassEndInfo) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetSemaphoreCounterValue(device, semaphore, pValue);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetSemaphoreCounterValue(&submit->command, cmd_flags, device, semaphore, pValue);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetSemaphoreCounterValue_reply(device, semaphore, pValue) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkWaitSemaphores(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkWaitSemaphores(device, pWaitInfo, timeout);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkWaitSemaphores(&submit->command, cmd_flags, device, pWaitInfo, timeout);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitSemaphores_reply(device, pWaitInfo, timeout) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkSignalSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkSignalSemaphore(device, pSignalInfo);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkSignalSemaphore(&submit->command, cmd_flags, device, pSignalInfo);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSignalSemaphore_reply(device, pSignalInfo) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdDrawIndirectCount(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdDrawIndirectCount(&submit->command, cmd_flags, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndirectCount_reply(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdDrawIndexedIndirectCount(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdDrawIndexedIndirectCount(&submit->command, cmd_flags, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndexedIndirectCount_reply(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBindTransformFeedbackBuffersEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBindTransformFeedbackBuffersEXT(&submit->command, cmd_flags, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT_reply(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBeginTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBeginTransformFeedbackEXT(&submit->command, cmd_flags, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginTransformFeedbackEXT_reply(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdEndTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdEndTransformFeedbackEXT(&submit->command, cmd_flags, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndTransformFeedbackEXT_reply(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdBeginQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdBeginQueryIndexedEXT(&submit->command, cmd_flags, commandBuffer, queryPool, query, flags, index);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginQueryIndexedEXT_reply(commandBuffer, queryPool, query, flags, index) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdEndQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdEndQueryIndexedEXT(&submit->command, cmd_flags, commandBuffer, queryPool, query, index);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndQueryIndexedEXT_reply(commandBuffer, queryPool, query, index) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCmdDrawIndirectByteCountEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCmdDrawIndirectByteCountEXT(&submit->command, cmd_flags, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndirectByteCountEXT_reply(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(&submit->command, cmd_flags, device, image, pProperties);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(device, image, pProperties) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetBufferOpaqueCaptureAddress(device, pInfo);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetBufferOpaqueCaptureAddress(&submit->command, cmd_flags, device, pInfo);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferOpaqueCaptureAddress_reply(device, pInfo) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetBufferDeviceAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetBufferDeviceAddress(device, pInfo);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetBufferDeviceAddress(&submit->command, cmd_flags, device, pInfo);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferDeviceAddress_reply(device, pInfo) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(&submit->command, cmd_flags, device, pInfo);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(device, pInfo) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const VkCommandStreamDescriptionMESA* pStream, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkSetReplyCommandStreamMESA(pStream);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkSetReplyCommandStreamMESA(&submit->command, cmd_flags, pStream);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetReplyCommandStreamMESA_reply(pStream) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, size_t position, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkSeekReplyCommandStreamMESA(position);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkSeekReplyCommandStreamMESA(&submit->command, cmd_flags, position);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSeekReplyCommandStreamMESA_reply(position) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkExecuteCommandStreamsMESA(streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkExecuteCommandStreamsMESA(&submit->command, cmd_flags, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkExecuteCommandStreamsMESA_reply(streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkCreateRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkCreateRingMESA(ring, pCreateInfo);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkCreateRingMESA(&submit->command, cmd_flags, ring, pCreateInfo);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRingMESA_reply(ring, pCreateInfo) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkDestroyRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkDestroyRingMESA(ring);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkDestroyRingMESA(&submit->command, cmd_flags, ring);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRingMESA_reply(ring) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkNotifyRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkNotifyRingMESA(ring, seqno, flags);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkNotifyRingMESA(&submit->command, cmd_flags, ring, seqno, flags);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkNotifyRingMESA_reply(ring, seqno, flags) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline void vn_submit_vkWriteRingExtraMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, size_t offset, uint32_t value, struct vn_instance_submit_command *submit)
-{
-    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
-    void *cmd_data = local_cmd_data;
-    size_t cmd_size = vn_sizeof_vkWriteRingExtraMESA(ring, offset, value);
-    if (cmd_size > sizeof(local_cmd_data)) {
-        cmd_data = malloc(cmd_size);
-        if (!cmd_data)
-            cmd_size = 0;
-    }
-
-    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
-    if (cmd_size)
-        vn_encode_vkWriteRingExtraMESA(&submit->command, cmd_flags, ring, offset, value);
-    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWriteRingExtraMESA_reply(ring, offset, value) : 0;
-    vn_instance_submit_command(vn_instance, submit);
-
-    if (cmd_data != local_cmd_data)
-        free(cmd_data);
-}
-
-static inline VkResult vn_call_vkCreateInstance(struct vn_instance *vn_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateInstance(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pCreateInfo, pAllocator, pInstance, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateInstance_reply(&submit.reply, pCreateInfo, pAllocator, pInstance);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateInstance(struct vn_instance *vn_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateInstance(vn_instance, 0, pCreateInfo, pAllocator, pInstance, &submit);
-}
-
-static inline void vn_call_vkDestroyInstance(struct vn_instance *vn_instance, VkInstance instance, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyInstance(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyInstance_reply(&submit.reply, instance, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyInstance(struct vn_instance *vn_instance, VkInstance instance, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyInstance(vn_instance, 0, instance, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumeratePhysicalDevices(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkEnumeratePhysicalDevices_reply(&submit.reply, instance, pPhysicalDeviceCount, pPhysicalDevices);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumeratePhysicalDevices(vn_instance, 0, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceProperties_reply(&submit.reply, physicalDevice, pProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceProperties(vn_instance, 0, physicalDevice, pProperties, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(&submit.reply, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(&submit.reply, physicalDevice, pMemoryProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, 0, physicalDevice, pMemoryProperties, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceFeatures_reply(&submit.reply, physicalDevice, pFeatures);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, 0, physicalDevice, pFeatures, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceFormatProperties_reply(&submit.reply, physicalDevice, format, pFormatProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit);
-}
-
-static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(&submit.reply, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, 0, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
-}
-
-static inline VkResult vn_call_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateDevice_reply(&submit.reply, physicalDevice, pCreateInfo, pAllocator, pDevice);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateDevice(vn_instance, 0, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
-}
-
-static inline void vn_call_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyDevice_reply(&submit.reply, device, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyDevice(vn_instance, 0, device, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, uint32_t* pApiVersion)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumerateInstanceVersion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pApiVersion, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkEnumerateInstanceVersion_reply(&submit.reply, pApiVersion);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, uint32_t* pApiVersion)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumerateInstanceVersion(vn_instance, 0, pApiVersion, &submit);
-}
-
-static inline VkResult vn_call_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumerateInstanceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pPropertyCount, pProperties, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkEnumerateInstanceLayerProperties_reply(&submit.reply, pPropertyCount, pProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumerateInstanceLayerProperties(vn_instance, 0, pPropertyCount, pProperties, &submit);
-}
-
-static inline VkResult vn_call_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumerateInstanceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pLayerName, pPropertyCount, pProperties, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkEnumerateInstanceExtensionProperties_reply(&submit.reply, pLayerName, pPropertyCount, pProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumerateInstanceExtensionProperties(vn_instance, 0, pLayerName, pPropertyCount, pProperties, &submit);
-}
-
-static inline VkResult vn_call_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pPropertyCount, pProperties, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkEnumerateDeviceLayerProperties_reply(&submit.reply, physicalDevice, pPropertyCount, pProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, 0, physicalDevice, pPropertyCount, pProperties, &submit);
-}
-
-static inline VkResult vn_call_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkEnumerateDeviceExtensionProperties_reply(&submit.reply, physicalDevice, pLayerName, pPropertyCount, pProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, 0, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
-}
-
-static inline void vn_call_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDeviceQueue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queueFamilyIndex, queueIndex, pQueue, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetDeviceQueue_reply(&submit.reply, device, queueFamilyIndex, queueIndex, pQueue);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDeviceQueue(vn_instance, 0, device, queueFamilyIndex, queueIndex, pQueue, &submit);
-}
-
-static inline VkResult vn_call_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkQueueSubmit(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, submitCount, pSubmits, fence, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkQueueSubmit_reply(&submit.reply, queue, submitCount, pSubmits, fence);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkQueueSubmit(vn_instance, 0, queue, submitCount, pSubmits, fence, &submit);
-}
-
-static inline VkResult vn_call_vkQueueWaitIdle(struct vn_instance *vn_instance, VkQueue queue)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkQueueWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkQueueWaitIdle_reply(&submit.reply, queue);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkQueueWaitIdle(struct vn_instance *vn_instance, VkQueue queue)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkQueueWaitIdle(vn_instance, 0, queue, &submit);
-}
-
-static inline VkResult vn_call_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDeviceWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkDeviceWaitIdle_reply(&submit.reply, device);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDeviceWaitIdle(vn_instance, 0, device, &submit);
-}
-
-static inline VkResult vn_call_vkAllocateMemory(struct vn_instance *vn_instance, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkAllocateMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pAllocator, pMemory, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkAllocateMemory_reply(&submit.reply, device, pAllocateInfo, pAllocator, pMemory);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkAllocateMemory(struct vn_instance *vn_instance, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkAllocateMemory(vn_instance, 0, device, pAllocateInfo, pAllocator, pMemory, &submit);
-}
-
-static inline void vn_call_vkFreeMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkFreeMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkFreeMemory_reply(&submit.reply, device, memory, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkFreeMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkFreeMemory(vn_instance, 0, device, memory, pAllocator, &submit);
-}
-
-static inline void vn_call_vkUnmapMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkUnmapMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkUnmapMemory_reply(&submit.reply, device, memory);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkUnmapMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkUnmapMemory(vn_instance, 0, device, memory, &submit);
-}
-
-static inline VkResult vn_call_vkFlushMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkFlushMappedMemoryRanges(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memoryRangeCount, pMemoryRanges, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkFlushMappedMemoryRanges_reply(&submit.reply, device, memoryRangeCount, pMemoryRanges);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkFlushMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkFlushMappedMemoryRanges(vn_instance, 0, device, memoryRangeCount, pMemoryRanges, &submit);
-}
-
-static inline VkResult vn_call_vkInvalidateMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkInvalidateMappedMemoryRanges(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memoryRangeCount, pMemoryRanges, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkInvalidateMappedMemoryRanges_reply(&submit.reply, device, memoryRangeCount, pMemoryRanges);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkInvalidateMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkInvalidateMappedMemoryRanges(vn_instance, 0, device, memoryRangeCount, pMemoryRanges, &submit);
-}
-
-static inline void vn_call_vkGetDeviceMemoryCommitment(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDeviceMemoryCommitment(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, pCommittedMemoryInBytes, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetDeviceMemoryCommitment_reply(&submit.reply, device, memory, pCommittedMemoryInBytes);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetDeviceMemoryCommitment(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDeviceMemoryCommitment(vn_instance, 0, device, memory, pCommittedMemoryInBytes, &submit);
-}
-
-static inline void vn_call_vkGetBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetBufferMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, pMemoryRequirements, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetBufferMemoryRequirements_reply(&submit.reply, device, buffer, pMemoryRequirements);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetBufferMemoryRequirements(vn_instance, 0, device, buffer, pMemoryRequirements, &submit);
-}
-
-static inline VkResult vn_call_vkBindBufferMemory(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkBindBufferMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, memory, memoryOffset, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkBindBufferMemory_reply(&submit.reply, device, buffer, memory, memoryOffset);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkBindBufferMemory(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkBindBufferMemory(vn_instance, 0, device, buffer, memory, memoryOffset, &submit);
-}
-
-static inline void vn_call_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pMemoryRequirements, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetImageMemoryRequirements_reply(&submit.reply, device, image, pMemoryRequirements);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageMemoryRequirements(vn_instance, 0, device, image, pMemoryRequirements, &submit);
-}
-
-static inline VkResult vn_call_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkBindImageMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, memory, memoryOffset, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkBindImageMemory_reply(&submit.reply, device, image, memory, memoryOffset);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkBindImageMemory(vn_instance, 0, device, image, memory, memoryOffset, &submit);
-}
-
-static inline void vn_call_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetImageSparseMemoryRequirements_reply(&submit.reply, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, 0, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(&submit.reply, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, 0, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
-}
-
-static inline VkResult vn_call_vkQueueBindSparse(struct vn_instance *vn_instance, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkQueueBindSparse(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, bindInfoCount, pBindInfo, fence, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkQueueBindSparse_reply(&submit.reply, queue, bindInfoCount, pBindInfo, fence);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkQueueBindSparse(struct vn_instance *vn_instance, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkQueueBindSparse(vn_instance, 0, queue, bindInfoCount, pBindInfo, fence, &submit);
-}
-
-static inline VkResult vn_call_vkCreateFence(struct vn_instance *vn_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateFence(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pFence, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateFence_reply(&submit.reply, device, pCreateInfo, pAllocator, pFence);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateFence(struct vn_instance *vn_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateFence(vn_instance, 0, device, pCreateInfo, pAllocator, pFence, &submit);
-}
-
-static inline void vn_call_vkDestroyFence(struct vn_instance *vn_instance, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyFence(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyFence_reply(&submit.reply, device, fence, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyFence(struct vn_instance *vn_instance, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyFence(vn_instance, 0, device, fence, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkResetFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetFences(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fenceCount, pFences, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkResetFences_reply(&submit.reply, device, fenceCount, pFences);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkResetFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetFences(vn_instance, 0, device, fenceCount, pFences, &submit);
-}
-
-static inline VkResult vn_call_vkGetFenceStatus(struct vn_instance *vn_instance, VkDevice device, VkFence fence)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetFenceStatus(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkGetFenceStatus_reply(&submit.reply, device, fence);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetFenceStatus(struct vn_instance *vn_instance, VkDevice device, VkFence fence)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetFenceStatus(vn_instance, 0, device, fence, &submit);
-}
-
-static inline VkResult vn_call_vkWaitForFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkWaitForFences(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fenceCount, pFences, waitAll, timeout, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkWaitForFences_reply(&submit.reply, device, fenceCount, pFences, waitAll, timeout);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkWaitForFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkWaitForFences(vn_instance, 0, device, fenceCount, pFences, waitAll, timeout, &submit);
-}
-
-static inline VkResult vn_call_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSemaphore, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateSemaphore_reply(&submit.reply, device, pCreateInfo, pAllocator, pSemaphore);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateSemaphore(vn_instance, 0, device, pCreateInfo, pAllocator, pSemaphore, &submit);
-}
-
-static inline void vn_call_vkDestroySemaphore(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroySemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroySemaphore_reply(&submit.reply, device, semaphore, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroySemaphore(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroySemaphore(vn_instance, 0, device, semaphore, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkCreateEvent(struct vn_instance *vn_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pEvent, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateEvent_reply(&submit.reply, device, pCreateInfo, pAllocator, pEvent);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateEvent(struct vn_instance *vn_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateEvent(vn_instance, 0, device, pCreateInfo, pAllocator, pEvent, &submit);
-}
-
-static inline void vn_call_vkDestroyEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyEvent_reply(&submit.reply, device, event, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyEvent(vn_instance, 0, device, event, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkGetEventStatus(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetEventStatus(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkGetEventStatus_reply(&submit.reply, device, event);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetEventStatus(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetEventStatus(vn_instance, 0, device, event, &submit);
-}
-
-static inline VkResult vn_call_vkSetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkSetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkSetEvent_reply(&submit.reply, device, event);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkSetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkSetEvent(vn_instance, 0, device, event, &submit);
-}
-
-static inline VkResult vn_call_vkResetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkResetEvent_reply(&submit.reply, device, event);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkResetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetEvent(vn_instance, 0, device, event, &submit);
-}
-
-static inline VkResult vn_call_vkCreateQueryPool(struct vn_instance *vn_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pQueryPool, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateQueryPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pQueryPool);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateQueryPool(struct vn_instance *vn_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateQueryPool(vn_instance, 0, device, pCreateInfo, pAllocator, pQueryPool, &submit);
-}
-
-static inline void vn_call_vkDestroyQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyQueryPool_reply(&submit.reply, device, queryPool, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyQueryPool(vn_instance, 0, device, queryPool, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetQueryPoolResults(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkGetQueryPoolResults_reply(&submit.reply, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetQueryPoolResults(vn_instance, 0, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, &submit);
-}
-
-static inline void vn_call_vkResetQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, firstQuery, queryCount, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkResetQueryPool_reply(&submit.reply, device, queryPool, firstQuery, queryCount);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkResetQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetQueryPool(vn_instance, 0, device, queryPool, firstQuery, queryCount, &submit);
-}
-
-static inline VkResult vn_call_vkCreateBuffer(struct vn_instance *vn_instance, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pBuffer, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateBuffer_reply(&submit.reply, device, pCreateInfo, pAllocator, pBuffer);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateBuffer(struct vn_instance *vn_instance, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateBuffer(vn_instance, 0, device, pCreateInfo, pAllocator, pBuffer, &submit);
-}
-
-static inline void vn_call_vkDestroyBuffer(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyBuffer_reply(&submit.reply, device, buffer, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyBuffer(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyBuffer(vn_instance, 0, device, buffer, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateBufferView_reply(&submit.reply, device, pCreateInfo, pAllocator, pView);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateBufferView(vn_instance, 0, device, pCreateInfo, pAllocator, pView, &submit);
-}
-
-static inline void vn_call_vkDestroyBufferView(struct vn_instance *vn_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bufferView, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyBufferView_reply(&submit.reply, device, bufferView, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyBufferView(struct vn_instance *vn_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyBufferView(vn_instance, 0, device, bufferView, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pImage, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateImage_reply(&submit.reply, device, pCreateInfo, pAllocator, pImage);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateImage(vn_instance, 0, device, pCreateInfo, pAllocator, pImage, &submit);
-}
-
-static inline void vn_call_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyImage_reply(&submit.reply, device, image, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyImage(vn_instance, 0, device, image, pAllocator, &submit);
-}
-
-static inline void vn_call_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageSubresourceLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSubresource, pLayout, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetImageSubresourceLayout_reply(&submit.reply, device, image, pSubresource, pLayout);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageSubresourceLayout(vn_instance, 0, device, image, pSubresource, pLayout, &submit);
-}
-
-static inline VkResult vn_call_vkCreateImageView(struct vn_instance *vn_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateImageView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateImageView_reply(&submit.reply, device, pCreateInfo, pAllocator, pView);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateImageView(struct vn_instance *vn_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateImageView(vn_instance, 0, device, pCreateInfo, pAllocator, pView, &submit);
-}
-
-static inline void vn_call_vkDestroyImageView(struct vn_instance *vn_instance, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyImageView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, imageView, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyImageView_reply(&submit.reply, device, imageView, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyImageView(struct vn_instance *vn_instance, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyImageView(vn_instance, 0, device, imageView, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkCreateShaderModule(struct vn_instance *vn_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateShaderModule(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pShaderModule, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateShaderModule_reply(&submit.reply, device, pCreateInfo, pAllocator, pShaderModule);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateShaderModule(struct vn_instance *vn_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateShaderModule(vn_instance, 0, device, pCreateInfo, pAllocator, pShaderModule, &submit);
-}
-
-static inline void vn_call_vkDestroyShaderModule(struct vn_instance *vn_instance, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyShaderModule(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, shaderModule, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyShaderModule_reply(&submit.reply, device, shaderModule, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyShaderModule(struct vn_instance *vn_instance, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyShaderModule(vn_instance, 0, device, shaderModule, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkCreatePipelineCache(struct vn_instance *vn_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreatePipelineCache(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPipelineCache, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreatePipelineCache_reply(&submit.reply, device, pCreateInfo, pAllocator, pPipelineCache);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreatePipelineCache(struct vn_instance *vn_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreatePipelineCache(vn_instance, 0, device, pCreateInfo, pAllocator, pPipelineCache, &submit);
-}
-
-static inline void vn_call_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyPipelineCache(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyPipelineCache_reply(&submit.reply, device, pipelineCache, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyPipelineCache(vn_instance, 0, device, pipelineCache, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPipelineCacheData(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, pDataSize, pData, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkGetPipelineCacheData_reply(&submit.reply, device, pipelineCache, pDataSize, pData);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPipelineCacheData(vn_instance, 0, device, pipelineCache, pDataSize, pData, &submit);
-}
-
-static inline VkResult vn_call_vkMergePipelineCaches(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkMergePipelineCaches(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, dstCache, srcCacheCount, pSrcCaches, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkMergePipelineCaches_reply(&submit.reply, device, dstCache, srcCacheCount, pSrcCaches);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkMergePipelineCaches(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkMergePipelineCaches(vn_instance, 0, device, dstCache, srcCacheCount, pSrcCaches, &submit);
-}
-
-static inline VkResult vn_call_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateGraphicsPipelines(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateGraphicsPipelines_reply(&submit.reply, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateGraphicsPipelines(vn_instance, 0, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
-}
-
-static inline VkResult vn_call_vkCreateComputePipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateComputePipelines(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateComputePipelines_reply(&submit.reply, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateComputePipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateComputePipelines(vn_instance, 0, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
-}
-
-static inline void vn_call_vkDestroyPipeline(struct vn_instance *vn_instance, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyPipeline(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipeline, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyPipeline_reply(&submit.reply, device, pipeline, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyPipeline(struct vn_instance *vn_instance, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyPipeline(vn_instance, 0, device, pipeline, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreatePipelineLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPipelineLayout, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreatePipelineLayout_reply(&submit.reply, device, pCreateInfo, pAllocator, pPipelineLayout);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreatePipelineLayout(vn_instance, 0, device, pCreateInfo, pAllocator, pPipelineLayout, &submit);
-}
-
-static inline void vn_call_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyPipelineLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineLayout, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyPipelineLayout_reply(&submit.reply, device, pipelineLayout, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyPipelineLayout(vn_instance, 0, device, pipelineLayout, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateSampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSampler, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateSampler_reply(&submit.reply, device, pCreateInfo, pAllocator, pSampler);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateSampler(vn_instance, 0, device, pCreateInfo, pAllocator, pSampler, &submit);
-}
-
-static inline void vn_call_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroySampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, sampler, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroySampler_reply(&submit.reply, device, sampler, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroySampler(vn_instance, 0, device, sampler, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateDescriptorSetLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSetLayout, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateDescriptorSetLayout_reply(&submit.reply, device, pCreateInfo, pAllocator, pSetLayout);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateDescriptorSetLayout(vn_instance, 0, device, pCreateInfo, pAllocator, pSetLayout, &submit);
-}
-
-static inline void vn_call_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyDescriptorSetLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorSetLayout, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyDescriptorSetLayout_reply(&submit.reply, device, descriptorSetLayout, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyDescriptorSetLayout(vn_instance, 0, device, descriptorSetLayout, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorPool, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateDescriptorPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pDescriptorPool);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateDescriptorPool(vn_instance, 0, device, pCreateInfo, pAllocator, pDescriptorPool, &submit);
-}
-
-static inline void vn_call_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyDescriptorPool_reply(&submit.reply, device, descriptorPool, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyDescriptorPool(vn_instance, 0, device, descriptorPool, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkResetDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, flags, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkResetDescriptorPool_reply(&submit.reply, device, descriptorPool, flags);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkResetDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetDescriptorPool(vn_instance, 0, device, descriptorPool, flags, &submit);
-}
-
-static inline VkResult vn_call_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkAllocateDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pDescriptorSets, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkAllocateDescriptorSets_reply(&submit.reply, device, pAllocateInfo, pDescriptorSets);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkAllocateDescriptorSets(vn_instance, 0, device, pAllocateInfo, pDescriptorSets, &submit);
-}
-
-static inline VkResult vn_call_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkFreeDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, descriptorSetCount, pDescriptorSets, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkFreeDescriptorSets_reply(&submit.reply, device, descriptorPool, descriptorSetCount, pDescriptorSets);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkFreeDescriptorSets(vn_instance, 0, device, descriptorPool, descriptorSetCount, pDescriptorSets, &submit);
-}
-
-static inline void vn_call_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkUpdateDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkUpdateDescriptorSets_reply(&submit.reply, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkUpdateDescriptorSets(vn_instance, 0, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, &submit);
-}
-
-static inline VkResult vn_call_vkCreateFramebuffer(struct vn_instance *vn_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateFramebuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pFramebuffer, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateFramebuffer_reply(&submit.reply, device, pCreateInfo, pAllocator, pFramebuffer);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateFramebuffer(struct vn_instance *vn_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateFramebuffer(vn_instance, 0, device, pCreateInfo, pAllocator, pFramebuffer, &submit);
-}
-
-static inline void vn_call_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyFramebuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, framebuffer, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyFramebuffer_reply(&submit.reply, device, framebuffer, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyFramebuffer(vn_instance, 0, device, framebuffer, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateRenderPass_reply(&submit.reply, device, pCreateInfo, pAllocator, pRenderPass);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateRenderPass(vn_instance, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit);
-}
-
-static inline void vn_call_vkDestroyRenderPass(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyRenderPass_reply(&submit.reply, device, renderPass, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyRenderPass(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyRenderPass(vn_instance, 0, device, renderPass, pAllocator, &submit);
-}
-
-static inline void vn_call_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetRenderAreaGranularity(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pGranularity, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetRenderAreaGranularity_reply(&submit.reply, device, renderPass, pGranularity);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetRenderAreaGranularity(vn_instance, 0, device, renderPass, pGranularity, &submit);
-}
-
-static inline VkResult vn_call_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pCommandPool, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateCommandPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pCommandPool);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateCommandPool(vn_instance, 0, device, pCreateInfo, pAllocator, pCommandPool, &submit);
-}
-
-static inline void vn_call_vkDestroyCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyCommandPool_reply(&submit.reply, device, commandPool, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyCommandPool(vn_instance, 0, device, commandPool, pAllocator, &submit);
-}
-
-static inline VkResult vn_call_vkResetCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkResetCommandPool_reply(&submit.reply, device, commandPool, flags);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkResetCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetCommandPool(vn_instance, 0, device, commandPool, flags, &submit);
-}
-
-static inline VkResult vn_call_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkAllocateCommandBuffers(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pCommandBuffers, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkAllocateCommandBuffers_reply(&submit.reply, device, pAllocateInfo, pCommandBuffers);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkAllocateCommandBuffers(vn_instance, 0, device, pAllocateInfo, pCommandBuffers, &submit);
-}
-
-static inline void vn_call_vkFreeCommandBuffers(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkFreeCommandBuffers(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, commandBufferCount, pCommandBuffers, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkFreeCommandBuffers_reply(&submit.reply, device, commandPool, commandBufferCount, pCommandBuffers);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkFreeCommandBuffers(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkFreeCommandBuffers(vn_instance, 0, device, commandPool, commandBufferCount, pCommandBuffers, &submit);
-}
-
-static inline VkResult vn_call_vkBeginCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkBeginCommandBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pBeginInfo, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkBeginCommandBuffer_reply(&submit.reply, commandBuffer, pBeginInfo);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkBeginCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkBeginCommandBuffer(vn_instance, 0, commandBuffer, pBeginInfo, &submit);
-}
-
-static inline VkResult vn_call_vkEndCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEndCommandBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkEndCommandBuffer_reply(&submit.reply, commandBuffer);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkEndCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEndCommandBuffer(vn_instance, 0, commandBuffer, &submit);
-}
-
-static inline VkResult vn_call_vkResetCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetCommandBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, flags, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkResetCommandBuffer_reply(&submit.reply, commandBuffer, flags);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkResetCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkResetCommandBuffer(vn_instance, 0, commandBuffer, flags, &submit);
-}
-
-static inline void vn_call_vkCmdBindPipeline(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBindPipeline(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pipelineBindPoint, pipeline, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBindPipeline_reply(&submit.reply, commandBuffer, pipelineBindPoint, pipeline);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBindPipeline(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBindPipeline(vn_instance, 0, commandBuffer, pipelineBindPoint, pipeline, &submit);
-}
-
-static inline void vn_call_vkCmdSetViewport(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetViewport(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstViewport, viewportCount, pViewports, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetViewport_reply(&submit.reply, commandBuffer, firstViewport, viewportCount, pViewports);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetViewport(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetViewport(vn_instance, 0, commandBuffer, firstViewport, viewportCount, pViewports, &submit);
-}
-
-static inline void vn_call_vkCmdSetScissor(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetScissor(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstScissor, scissorCount, pScissors, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetScissor_reply(&submit.reply, commandBuffer, firstScissor, scissorCount, pScissors);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetScissor(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetScissor(vn_instance, 0, commandBuffer, firstScissor, scissorCount, pScissors, &submit);
-}
-
-static inline void vn_call_vkCmdSetLineWidth(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float lineWidth)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetLineWidth(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, lineWidth, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetLineWidth_reply(&submit.reply, commandBuffer, lineWidth);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetLineWidth(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float lineWidth)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetLineWidth(vn_instance, 0, commandBuffer, lineWidth, &submit);
-}
-
-static inline void vn_call_vkCmdSetDepthBias(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetDepthBias(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetDepthBias_reply(&submit.reply, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetDepthBias(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetDepthBias(vn_instance, 0, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor, &submit);
-}
-
-static inline void vn_call_vkCmdSetBlendConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const float blendConstants[4])
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetBlendConstants(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, blendConstants, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetBlendConstants_reply(&submit.reply, commandBuffer, blendConstants);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetBlendConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const float blendConstants[4])
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetBlendConstants(vn_instance, 0, commandBuffer, blendConstants, &submit);
-}
-
-static inline void vn_call_vkCmdSetDepthBounds(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetDepthBounds(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, minDepthBounds, maxDepthBounds, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetDepthBounds_reply(&submit.reply, commandBuffer, minDepthBounds, maxDepthBounds);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetDepthBounds(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetDepthBounds(vn_instance, 0, commandBuffer, minDepthBounds, maxDepthBounds, &submit);
-}
-
-static inline void vn_call_vkCmdSetStencilCompareMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetStencilCompareMask(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, faceMask, compareMask, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetStencilCompareMask_reply(&submit.reply, commandBuffer, faceMask, compareMask);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetStencilCompareMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetStencilCompareMask(vn_instance, 0, commandBuffer, faceMask, compareMask, &submit);
-}
-
-static inline void vn_call_vkCmdSetStencilWriteMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetStencilWriteMask(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, faceMask, writeMask, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetStencilWriteMask_reply(&submit.reply, commandBuffer, faceMask, writeMask);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetStencilWriteMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetStencilWriteMask(vn_instance, 0, commandBuffer, faceMask, writeMask, &submit);
-}
-
-static inline void vn_call_vkCmdSetStencilReference(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetStencilReference(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, faceMask, reference, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetStencilReference_reply(&submit.reply, commandBuffer, faceMask, reference);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetStencilReference(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetStencilReference(vn_instance, 0, commandBuffer, faceMask, reference, &submit);
-}
-
-static inline void vn_call_vkCmdBindDescriptorSets(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBindDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBindDescriptorSets_reply(&submit.reply, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBindDescriptorSets(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBindDescriptorSets(vn_instance, 0, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets, &submit);
-}
-
-static inline void vn_call_vkCmdBindIndexBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBindIndexBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, indexType, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBindIndexBuffer_reply(&submit.reply, commandBuffer, buffer, offset, indexType);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBindIndexBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBindIndexBuffer(vn_instance, 0, commandBuffer, buffer, offset, indexType, &submit);
-}
-
-static inline void vn_call_vkCmdBindVertexBuffers(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBindVertexBuffers(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBindVertexBuffers_reply(&submit.reply, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBindVertexBuffers(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBindVertexBuffers(vn_instance, 0, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, &submit);
-}
-
-static inline void vn_call_vkCmdDraw(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDraw(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdDraw_reply(&submit.reply, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdDraw(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDraw(vn_instance, 0, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance, &submit);
-}
-
-static inline void vn_call_vkCmdDrawIndexed(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndexed(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdDrawIndexed_reply(&submit.reply, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdDrawIndexed(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndexed(vn_instance, 0, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance, &submit);
-}
-
-static inline void vn_call_vkCmdDrawIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndirect(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, drawCount, stride, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdDrawIndirect_reply(&submit.reply, commandBuffer, buffer, offset, drawCount, stride);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdDrawIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndirect(vn_instance, 0, commandBuffer, buffer, offset, drawCount, stride, &submit);
-}
-
-static inline void vn_call_vkCmdDrawIndexedIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndexedIndirect(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, drawCount, stride, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdDrawIndexedIndirect_reply(&submit.reply, commandBuffer, buffer, offset, drawCount, stride);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdDrawIndexedIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndexedIndirect(vn_instance, 0, commandBuffer, buffer, offset, drawCount, stride, &submit);
-}
-
-static inline void vn_call_vkCmdDispatch(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDispatch(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, groupCountX, groupCountY, groupCountZ, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdDispatch_reply(&submit.reply, commandBuffer, groupCountX, groupCountY, groupCountZ);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdDispatch(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDispatch(vn_instance, 0, commandBuffer, groupCountX, groupCountY, groupCountZ, &submit);
-}
-
-static inline void vn_call_vkCmdDispatchIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDispatchIndirect(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdDispatchIndirect_reply(&submit.reply, commandBuffer, buffer, offset);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdDispatchIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDispatchIndirect(vn_instance, 0, commandBuffer, buffer, offset, &submit);
-}
-
-static inline void vn_call_vkCmdCopyBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdCopyBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdCopyBuffer_reply(&submit.reply, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdCopyBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdCopyBuffer(vn_instance, 0, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions, &submit);
-}
-
-static inline void vn_call_vkCmdCopyImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdCopyImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdCopyImage_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdCopyImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdCopyImage(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit);
-}
-
-static inline void vn_call_vkCmdBlitImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBlitImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBlitImage_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBlitImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBlitImage(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter, &submit);
-}
-
-static inline void vn_call_vkCmdCopyBufferToImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdCopyBufferToImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdCopyBufferToImage_reply(&submit.reply, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdCopyBufferToImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdCopyBufferToImage(vn_instance, 0, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions, &submit);
-}
-
-static inline void vn_call_vkCmdCopyImageToBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdCopyImageToBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdCopyImageToBuffer_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdCopyImageToBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdCopyImageToBuffer(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions, &submit);
-}
-
-static inline void vn_call_vkCmdUpdateBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdUpdateBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, dstBuffer, dstOffset, dataSize, pData, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdUpdateBuffer_reply(&submit.reply, commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdUpdateBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdUpdateBuffer(vn_instance, 0, commandBuffer, dstBuffer, dstOffset, dataSize, pData, &submit);
-}
-
-static inline void vn_call_vkCmdFillBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdFillBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, dstBuffer, dstOffset, size, data, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdFillBuffer_reply(&submit.reply, commandBuffer, dstBuffer, dstOffset, size, data);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdFillBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdFillBuffer(vn_instance, 0, commandBuffer, dstBuffer, dstOffset, size, data, &submit);
-}
-
-static inline void vn_call_vkCmdClearColorImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdClearColorImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdClearColorImage_reply(&submit.reply, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdClearColorImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdClearColorImage(vn_instance, 0, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges, &submit);
-}
-
-static inline void vn_call_vkCmdClearDepthStencilImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdClearDepthStencilImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdClearDepthStencilImage_reply(&submit.reply, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdClearDepthStencilImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdClearDepthStencilImage(vn_instance, 0, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges, &submit);
-}
-
-static inline void vn_call_vkCmdClearAttachments(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdClearAttachments(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, attachmentCount, pAttachments, rectCount, pRects, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdClearAttachments_reply(&submit.reply, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdClearAttachments(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdClearAttachments(vn_instance, 0, commandBuffer, attachmentCount, pAttachments, rectCount, pRects, &submit);
-}
-
-static inline void vn_call_vkCmdResolveImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdResolveImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdResolveImage_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdResolveImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdResolveImage(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit);
-}
-
-static inline void vn_call_vkCmdSetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, event, stageMask, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetEvent_reply(&submit.reply, commandBuffer, event, stageMask);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetEvent(vn_instance, 0, commandBuffer, event, stageMask, &submit);
-}
-
-static inline void vn_call_vkCmdResetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdResetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, event, stageMask, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdResetEvent_reply(&submit.reply, commandBuffer, event, stageMask);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdResetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdResetEvent(vn_instance, 0, commandBuffer, event, stageMask, &submit);
-}
-
-static inline void vn_call_vkCmdWaitEvents(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdWaitEvents(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdWaitEvents_reply(&submit.reply, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdWaitEvents(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdWaitEvents(vn_instance, 0, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit);
-}
-
-static inline void vn_call_vkCmdPipelineBarrier(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdPipelineBarrier(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdPipelineBarrier_reply(&submit.reply, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdPipelineBarrier(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdPipelineBarrier(vn_instance, 0, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit);
-}
-
-static inline void vn_call_vkCmdBeginQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBeginQuery(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, flags, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBeginQuery_reply(&submit.reply, commandBuffer, queryPool, query, flags);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBeginQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBeginQuery(vn_instance, 0, commandBuffer, queryPool, query, flags, &submit);
-}
-
-static inline void vn_call_vkCmdEndQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdEndQuery(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdEndQuery_reply(&submit.reply, commandBuffer, queryPool, query);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdEndQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdEndQuery(vn_instance, 0, commandBuffer, queryPool, query, &submit);
-}
-
-static inline void vn_call_vkCmdResetQueryPool(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdResetQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, firstQuery, queryCount, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdResetQueryPool_reply(&submit.reply, commandBuffer, queryPool, firstQuery, queryCount);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdResetQueryPool(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdResetQueryPool(vn_instance, 0, commandBuffer, queryPool, firstQuery, queryCount, &submit);
-}
-
-static inline void vn_call_vkCmdWriteTimestamp(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdWriteTimestamp(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pipelineStage, queryPool, query, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdWriteTimestamp_reply(&submit.reply, commandBuffer, pipelineStage, queryPool, query);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdWriteTimestamp(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdWriteTimestamp(vn_instance, 0, commandBuffer, pipelineStage, queryPool, query, &submit);
-}
-
-static inline void vn_call_vkCmdCopyQueryPoolResults(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdCopyQueryPoolResults(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdCopyQueryPoolResults_reply(&submit.reply, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdCopyQueryPoolResults(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdCopyQueryPoolResults(vn_instance, 0, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags, &submit);
-}
-
-static inline void vn_call_vkCmdPushConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdPushConstants(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, layout, stageFlags, offset, size, pValues, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdPushConstants_reply(&submit.reply, commandBuffer, layout, stageFlags, offset, size, pValues);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdPushConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdPushConstants(vn_instance, 0, commandBuffer, layout, stageFlags, offset, size, pValues, &submit);
-}
-
-static inline void vn_call_vkCmdBeginRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBeginRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pRenderPassBegin, contents, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBeginRenderPass_reply(&submit.reply, commandBuffer, pRenderPassBegin, contents);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBeginRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBeginRenderPass(vn_instance, 0, commandBuffer, pRenderPassBegin, contents, &submit);
-}
-
-static inline void vn_call_vkCmdNextSubpass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkSubpassContents contents)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdNextSubpass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, contents, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdNextSubpass_reply(&submit.reply, commandBuffer, contents);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdNextSubpass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkSubpassContents contents)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdNextSubpass(vn_instance, 0, commandBuffer, contents, &submit);
-}
-
-static inline void vn_call_vkCmdEndRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdEndRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdEndRenderPass_reply(&submit.reply, commandBuffer);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdEndRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdEndRenderPass(vn_instance, 0, commandBuffer, &submit);
-}
-
-static inline void vn_call_vkCmdExecuteCommands(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdExecuteCommands(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, commandBufferCount, pCommandBuffers, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdExecuteCommands_reply(&submit.reply, commandBuffer, commandBufferCount, pCommandBuffers);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdExecuteCommands(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdExecuteCommands(vn_instance, 0, commandBuffer, commandBufferCount, pCommandBuffers, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceFeatures2_reply(&submit.reply, physicalDevice, pFeatures);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, 0, physicalDevice, pFeatures, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceProperties2_reply(&submit.reply, physicalDevice, pProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, 0, physicalDevice, pProperties, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(&submit.reply, physicalDevice, format, pFormatProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit);
-}
-
-static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(&submit.reply, physicalDevice, pImageFormatInfo, pImageFormatProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, 0, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(&submit.reply, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(&submit.reply, physicalDevice, pMemoryProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, 0, physicalDevice, pMemoryProperties, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(&submit.reply, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, 0, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
-}
-
-static inline void vn_call_vkTrimCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkTrimCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkTrimCommandPool_reply(&submit.reply, device, commandPool, flags);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkTrimCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkTrimCommandPool(vn_instance, 0, device, commandPool, flags, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(&submit.reply, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, 0, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(&submit.reply, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, 0, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
-}
-
-static inline void vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(&submit.reply, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, 0, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
-}
-
-static inline VkResult vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkEnumeratePhysicalDeviceGroups_reply(&submit.reply, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, 0, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
-}
-
-static inline void vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(&submit.reply, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, 0, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
-}
-
-static inline VkResult vn_call_vkBindBufferMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkBindBufferMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkBindBufferMemory2_reply(&submit.reply, device, bindInfoCount, pBindInfos);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkBindBufferMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkBindBufferMemory2(vn_instance, 0, device, bindInfoCount, pBindInfos, &submit);
-}
-
-static inline VkResult vn_call_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkBindImageMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkBindImageMemory2_reply(&submit.reply, device, bindInfoCount, pBindInfos);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkBindImageMemory2(vn_instance, 0, device, bindInfoCount, pBindInfos, &submit);
-}
-
-static inline void vn_call_vkCmdSetDeviceMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t deviceMask)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetDeviceMask(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, deviceMask, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdSetDeviceMask_reply(&submit.reply, commandBuffer, deviceMask);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdSetDeviceMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t deviceMask)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdSetDeviceMask(vn_instance, 0, commandBuffer, deviceMask, &submit);
-}
-
-static inline void vn_call_vkCmdDispatchBase(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDispatchBase(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdDispatchBase_reply(&submit.reply, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdDispatchBase(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDispatchBase(vn_instance, 0, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, &submit);
-}
-
-static inline VkResult vn_call_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateDescriptorUpdateTemplate(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateDescriptorUpdateTemplate_reply(&submit.reply, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateDescriptorUpdateTemplate(vn_instance, 0, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, &submit);
-}
-
-static inline void vn_call_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyDescriptorUpdateTemplate(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorUpdateTemplate, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyDescriptorUpdateTemplate_reply(&submit.reply, device, descriptorUpdateTemplate, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyDescriptorUpdateTemplate(vn_instance, 0, device, descriptorUpdateTemplate, pAllocator, &submit);
-}
-
-static inline void vn_call_vkGetBufferMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetBufferMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetBufferMemoryRequirements2_reply(&submit.reply, device, pInfo, pMemoryRequirements);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetBufferMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetBufferMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
-}
-
-static inline void vn_call_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetImageMemoryRequirements2_reply(&submit.reply, device, pInfo, pMemoryRequirements);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
-}
-
-static inline void vn_call_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetImageSparseMemoryRequirements2_reply(&submit.reply, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
-}
-
-static inline VkResult vn_call_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateSamplerYcbcrConversion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pYcbcrConversion, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateSamplerYcbcrConversion_reply(&submit.reply, device, pCreateInfo, pAllocator, pYcbcrConversion);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateSamplerYcbcrConversion(vn_instance, 0, device, pCreateInfo, pAllocator, pYcbcrConversion, &submit);
-}
-
-static inline void vn_call_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroySamplerYcbcrConversion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, ycbcrConversion, pAllocator, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroySamplerYcbcrConversion_reply(&submit.reply, device, ycbcrConversion, pAllocator);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroySamplerYcbcrConversion(vn_instance, 0, device, ycbcrConversion, pAllocator, &submit);
-}
-
-static inline void vn_call_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDeviceQueue2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pQueueInfo, pQueue, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetDeviceQueue2_reply(&submit.reply, device, pQueueInfo, pQueue);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDeviceQueue2(vn_instance, 0, device, pQueueInfo, pQueue, &submit);
-}
-
-static inline void vn_call_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDescriptorSetLayoutSupport(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pSupport, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkGetDescriptorSetLayoutSupport_reply(&submit.reply, device, pCreateInfo, pSupport);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDescriptorSetLayoutSupport(vn_instance, 0, device, pCreateInfo, pSupport, &submit);
-}
-
-static inline VkResult vn_call_vkCreateRenderPass2(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkCreateRenderPass2_reply(&submit.reply, device, pCreateInfo, pAllocator, pRenderPass);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkCreateRenderPass2(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateRenderPass2(vn_instance, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit);
-}
-
-static inline void vn_call_vkCmdBeginRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBeginRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pRenderPassBegin, pSubpassBeginInfo, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBeginRenderPass2_reply(&submit.reply, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBeginRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBeginRenderPass2(vn_instance, 0, commandBuffer, pRenderPassBegin, pSubpassBeginInfo, &submit);
-}
-
-static inline void vn_call_vkCmdNextSubpass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdNextSubpass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdNextSubpass2_reply(&submit.reply, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdNextSubpass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdNextSubpass2(vn_instance, 0, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, &submit);
-}
-
-static inline void vn_call_vkCmdEndRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdEndRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pSubpassEndInfo, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdEndRenderPass2_reply(&submit.reply, commandBuffer, pSubpassEndInfo);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdEndRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdEndRenderPass2(vn_instance, 0, commandBuffer, pSubpassEndInfo, &submit);
-}
-
-static inline VkResult vn_call_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetSemaphoreCounterValue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pValue, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkGetSemaphoreCounterValue_reply(&submit.reply, device, semaphore, pValue);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetSemaphoreCounterValue(vn_instance, 0, device, semaphore, pValue, &submit);
-}
-
-static inline VkResult vn_call_vkWaitSemaphores(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkWaitSemaphores(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pWaitInfo, timeout, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkWaitSemaphores_reply(&submit.reply, device, pWaitInfo, timeout);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkWaitSemaphores(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkWaitSemaphores(vn_instance, 0, device, pWaitInfo, timeout, &submit);
-}
-
-static inline VkResult vn_call_vkSignalSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkSignalSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pSignalInfo, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkSignalSemaphore_reply(&submit.reply, device, pSignalInfo);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkSignalSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkSignalSemaphore(vn_instance, 0, device, pSignalInfo, &submit);
-}
-
-static inline void vn_call_vkCmdDrawIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndirectCount(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdDrawIndirectCount_reply(&submit.reply, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdDrawIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndirectCount(vn_instance, 0, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit);
-}
-
-static inline void vn_call_vkCmdDrawIndexedIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndexedIndirectCount(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdDrawIndexedIndirectCount_reply(&submit.reply, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdDrawIndexedIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndexedIndirectCount(vn_instance, 0, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit);
-}
-
-static inline void vn_call_vkCmdBindTransformFeedbackBuffersEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBindTransformFeedbackBuffersEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBindTransformFeedbackBuffersEXT_reply(&submit.reply, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBindTransformFeedbackBuffersEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBindTransformFeedbackBuffersEXT(vn_instance, 0, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, &submit);
-}
-
-static inline void vn_call_vkCmdBeginTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBeginTransformFeedbackEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBeginTransformFeedbackEXT_reply(&submit.reply, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBeginTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBeginTransformFeedbackEXT(vn_instance, 0, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit);
-}
-
-static inline void vn_call_vkCmdEndTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdEndTransformFeedbackEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdEndTransformFeedbackEXT_reply(&submit.reply, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdEndTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdEndTransformFeedbackEXT(vn_instance, 0, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit);
-}
-
-static inline void vn_call_vkCmdBeginQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBeginQueryIndexedEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, flags, index, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdBeginQueryIndexedEXT_reply(&submit.reply, commandBuffer, queryPool, query, flags, index);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdBeginQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdBeginQueryIndexedEXT(vn_instance, 0, commandBuffer, queryPool, query, flags, index, &submit);
-}
-
-static inline void vn_call_vkCmdEndQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdEndQueryIndexedEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, index, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdEndQueryIndexedEXT_reply(&submit.reply, commandBuffer, queryPool, query, index);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdEndQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdEndQueryIndexedEXT(vn_instance, 0, commandBuffer, queryPool, query, index, &submit);
-}
-
-static inline void vn_call_vkCmdDrawIndirectByteCountEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndirectByteCountEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCmdDrawIndirectByteCountEXT_reply(&submit.reply, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCmdDrawIndirectByteCountEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCmdDrawIndirectByteCountEXT(vn_instance, 0, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, &submit);
-}
-
-static inline VkResult vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pProperties, &submit);
-    if (submit.reply_bo) {
-        const VkResult ret = vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(&submit.reply, device, image, pProperties);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, 0, device, image, pProperties, &submit);
-}
-
-static inline uint64_t vn_call_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetBufferOpaqueCaptureAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit);
-    if (submit.reply_bo) {
-        const uint64_t ret = vn_decode_vkGetBufferOpaqueCaptureAddress_reply(&submit.reply, device, pInfo);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetBufferOpaqueCaptureAddress(vn_instance, 0, device, pInfo, &submit);
-}
-
-static inline VkDeviceAddress vn_call_vkGetBufferDeviceAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetBufferDeviceAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit);
-    if (submit.reply_bo) {
-        const VkDeviceAddress ret = vn_decode_vkGetBufferDeviceAddress_reply(&submit.reply, device, pInfo);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetBufferDeviceAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetBufferDeviceAddress(vn_instance, 0, device, pInfo, &submit);
-}
-
-static inline uint64_t vn_call_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit);
-    if (submit.reply_bo) {
-        const uint64_t ret = vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(&submit.reply, device, pInfo);
-        vn_renderer_bo_unref(submit.reply_bo);
-        return ret;
-    } else {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-}
-
-static inline void vn_async_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(vn_instance, 0, device, pInfo, &submit);
-}
-
-static inline void vn_call_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, const VkCommandStreamDescriptionMESA* pStream)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkSetReplyCommandStreamMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pStream, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkSetReplyCommandStreamMESA_reply(&submit.reply, pStream);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, const VkCommandStreamDescriptionMESA* pStream)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkSetReplyCommandStreamMESA(vn_instance, 0, pStream, &submit);
-}
-
-static inline void vn_call_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, size_t position)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkSeekReplyCommandStreamMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, position, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkSeekReplyCommandStreamMESA_reply(&submit.reply, position);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, size_t position)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkSeekReplyCommandStreamMESA(vn_instance, 0, position, &submit);
-}
-
-static inline void vn_call_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkExecuteCommandStreamsMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkExecuteCommandStreamsMESA_reply(&submit.reply, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkExecuteCommandStreamsMESA(vn_instance, 0, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags, &submit);
-}
-
-static inline void vn_call_vkCreateRingMESA(struct vn_instance *vn_instance, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, pCreateInfo, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkCreateRingMESA_reply(&submit.reply, ring, pCreateInfo);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkCreateRingMESA(struct vn_instance *vn_instance, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkCreateRingMESA(vn_instance, 0, ring, pCreateInfo, &submit);
-}
-
-static inline void vn_call_vkDestroyRingMESA(struct vn_instance *vn_instance, uint64_t ring)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkDestroyRingMESA_reply(&submit.reply, ring);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkDestroyRingMESA(struct vn_instance *vn_instance, uint64_t ring)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkDestroyRingMESA(vn_instance, 0, ring, &submit);
-}
-
-static inline void vn_call_vkNotifyRingMESA(struct vn_instance *vn_instance, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkNotifyRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, seqno, flags, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkNotifyRingMESA_reply(&submit.reply, ring, seqno, flags);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkNotifyRingMESA(struct vn_instance *vn_instance, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkNotifyRingMESA(vn_instance, 0, ring, seqno, flags, &submit);
-}
-
-static inline void vn_call_vkWriteRingExtraMESA(struct vn_instance *vn_instance, uint64_t ring, size_t offset, uint32_t value)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkWriteRingExtraMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, offset, value, &submit);
-    if (submit.reply_bo) {
-        vn_decode_vkWriteRingExtraMESA_reply(&submit.reply, ring, offset, value);
-        vn_renderer_bo_unref(submit.reply_bo);
-    }
-}
-
-static inline void vn_async_vkWriteRingExtraMESA(struct vn_instance *vn_instance, uint64_t ring, size_t offset, uint32_t value)
-{
-    struct vn_instance_submit_command submit;
-    vn_submit_vkWriteRingExtraMESA(vn_instance, 0, ring, offset, value, &submit);
-}
-
-#endif /* VN_PROTOCOL_DRIVER_CALLS_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_command_buffer.h b/src/virtio/venus-protocol/vn_protocol_driver_command_buffer.h
new file mode 100644 (file)
index 0000000..bf05722
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_command_buffer.h
@@ -0,0 +1,7386 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_COMMAND_BUFFER_H
+#define VN_PROTOCOL_DRIVER_COMMAND_BUFFER_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkCommandBufferAllocateInfo chain */
+
+static inline size_t
+vn_sizeof_VkCommandBufferAllocateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkCommandBufferAllocateInfo_self(const VkCommandBufferAllocateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkCommandPool(&val->commandPool);
+    size += vn_sizeof_VkCommandBufferLevel(&val->level);
+    size += vn_sizeof_uint32_t(&val->commandBufferCount);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkCommandBufferAllocateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkCommandBufferAllocateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkCommandBufferAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkCommandBufferAllocateInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferAllocateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkCommandPool(enc, &val->commandPool);
+    vn_encode_VkCommandBufferLevel(enc, &val->level);
+    vn_encode_uint32_t(enc, &val->commandBufferCount);
+}
+
+static inline void
+vn_encode_VkCommandBufferAllocateInfo(struct vn_cs_encoder *enc, const VkCommandBufferAllocateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO });
+    vn_encode_VkCommandBufferAllocateInfo_pnext(enc, val->pNext);
+    vn_encode_VkCommandBufferAllocateInfo_self(enc, val);
+}
+
+/* struct VkCommandBufferInheritanceInfo chain */
+
+static inline size_t
+vn_sizeof_VkCommandBufferInheritanceInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkCommandBufferInheritanceInfo_self(const VkCommandBufferInheritanceInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkRenderPass(&val->renderPass);
+    size += vn_sizeof_uint32_t(&val->subpass);
+    size += vn_sizeof_VkFramebuffer(&val->framebuffer);
+    size += vn_sizeof_VkBool32(&val->occlusionQueryEnable);
+    size += vn_sizeof_VkFlags(&val->queryFlags);
+    size += vn_sizeof_VkFlags(&val->pipelineStatistics);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkCommandBufferInheritanceInfo_pnext(val->pNext);
+    size += vn_sizeof_VkCommandBufferInheritanceInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkCommandBufferInheritanceInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkCommandBufferInheritanceInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferInheritanceInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkRenderPass(enc, &val->renderPass);
+    vn_encode_uint32_t(enc, &val->subpass);
+    vn_encode_VkFramebuffer(enc, &val->framebuffer);
+    vn_encode_VkBool32(enc, &val->occlusionQueryEnable);
+    vn_encode_VkFlags(enc, &val->queryFlags);
+    vn_encode_VkFlags(enc, &val->pipelineStatistics);
+}
+
+static inline void
+vn_encode_VkCommandBufferInheritanceInfo(struct vn_cs_encoder *enc, const VkCommandBufferInheritanceInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO });
+    vn_encode_VkCommandBufferInheritanceInfo_pnext(enc, val->pNext);
+    vn_encode_VkCommandBufferInheritanceInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkCommandBufferInheritanceInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkCommandBufferInheritanceInfo_self(struct vn_cs_decoder *dec, VkCommandBufferInheritanceInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkRenderPass(dec, &val->renderPass);
+    vn_decode_uint32_t(dec, &val->subpass);
+    vn_decode_VkFramebuffer(dec, &val->framebuffer);
+    vn_decode_VkBool32(dec, &val->occlusionQueryEnable);
+    vn_decode_VkFlags(dec, &val->queryFlags);
+    vn_decode_VkFlags(dec, &val->pipelineStatistics);
+}
+
+static inline void
+vn_decode_VkCommandBufferInheritanceInfo(struct vn_cs_decoder *dec, VkCommandBufferInheritanceInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkCommandBufferInheritanceInfo_pnext(dec, val->pNext);
+    vn_decode_VkCommandBufferInheritanceInfo_self(dec, val);
+}
+
+/* struct VkDeviceGroupCommandBufferBeginInfo chain */
+
+static inline size_t
+vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_self(const VkDeviceGroupCommandBufferBeginInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->deviceMask);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDeviceGroupCommandBufferBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDeviceGroupCommandBufferBeginInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupCommandBufferBeginInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->deviceMask);
+}
+
+static inline void
+vn_encode_VkDeviceGroupCommandBufferBeginInfo(struct vn_cs_encoder *enc, const VkDeviceGroupCommandBufferBeginInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO });
+    vn_encode_VkDeviceGroupCommandBufferBeginInfo_pnext(enc, val->pNext);
+    vn_encode_VkDeviceGroupCommandBufferBeginInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkDeviceGroupCommandBufferBeginInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkDeviceGroupCommandBufferBeginInfo_self(struct vn_cs_decoder *dec, VkDeviceGroupCommandBufferBeginInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->deviceMask);
+}
+
+static inline void
+vn_decode_VkDeviceGroupCommandBufferBeginInfo(struct vn_cs_decoder *dec, VkDeviceGroupCommandBufferBeginInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkDeviceGroupCommandBufferBeginInfo_pnext(dec, val->pNext);
+    vn_decode_VkDeviceGroupCommandBufferBeginInfo_self(dec, val);
+}
+
+/* struct VkCommandBufferBeginInfo chain */
+
+static inline size_t
+vn_sizeof_VkCommandBufferBeginInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkCommandBufferBeginInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_self((const VkDeviceGroupCommandBufferBeginInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkCommandBufferBeginInfo_self(const VkCommandBufferBeginInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_simple_pointer(val->pInheritanceInfo);
+    if (val->pInheritanceInfo)
+        size += vn_sizeof_VkCommandBufferInheritanceInfo(val->pInheritanceInfo);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkCommandBufferBeginInfo_pnext(val->pNext);
+    size += vn_sizeof_VkCommandBufferBeginInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkCommandBufferBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkCommandBufferBeginInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkDeviceGroupCommandBufferBeginInfo_self(enc, (const VkDeviceGroupCommandBufferBeginInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkCommandBufferBeginInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferBeginInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    if (vn_encode_simple_pointer(enc, val->pInheritanceInfo))
+        vn_encode_VkCommandBufferInheritanceInfo(enc, val->pInheritanceInfo);
+}
+
+static inline void
+vn_encode_VkCommandBufferBeginInfo(struct vn_cs_encoder *enc, const VkCommandBufferBeginInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO });
+    vn_encode_VkCommandBufferBeginInfo_pnext(enc, val->pNext);
+    vn_encode_VkCommandBufferBeginInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkCommandBufferBeginInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return;
+
+    vn_decode_VkStructureType(dec, &stype);
+    while (true) {
+        assert(pnext);
+        if (pnext->sType == stype)
+            break;
+    }
+
+    switch ((int32_t)pnext->sType) {
+    case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+        vn_decode_VkCommandBufferBeginInfo_pnext(dec, pnext->pNext);
+        vn_decode_VkDeviceGroupCommandBufferBeginInfo_self(dec, (VkDeviceGroupCommandBufferBeginInfo *)pnext);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_decode_VkCommandBufferBeginInfo_self(struct vn_cs_decoder *dec, VkCommandBufferBeginInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkFlags(dec, &val->flags);
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkCommandBufferInheritanceInfo(dec, (VkCommandBufferInheritanceInfo *)val->pInheritanceInfo);
+    } else {
+        val->pInheritanceInfo = NULL;
+    }
+}
+
+static inline void
+vn_decode_VkCommandBufferBeginInfo(struct vn_cs_decoder *dec, VkCommandBufferBeginInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkCommandBufferBeginInfo_pnext(dec, val->pNext);
+    vn_decode_VkCommandBufferBeginInfo_self(dec, val);
+}
+
+/* struct VkBufferCopy */
+
+static inline size_t
+vn_sizeof_VkBufferCopy(const VkBufferCopy *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkDeviceSize(&val->srcOffset);
+    size += vn_sizeof_VkDeviceSize(&val->dstOffset);
+    size += vn_sizeof_VkDeviceSize(&val->size);
+    return size;
+}
+
+static inline void
+vn_encode_VkBufferCopy(struct vn_cs_encoder *enc, const VkBufferCopy *val)
+{
+    vn_encode_VkDeviceSize(enc, &val->srcOffset);
+    vn_encode_VkDeviceSize(enc, &val->dstOffset);
+    vn_encode_VkDeviceSize(enc, &val->size);
+}
+
+/* struct VkImageSubresourceLayers */
+
+static inline size_t
+vn_sizeof_VkImageSubresourceLayers(const VkImageSubresourceLayers *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->aspectMask);
+    size += vn_sizeof_uint32_t(&val->mipLevel);
+    size += vn_sizeof_uint32_t(&val->baseArrayLayer);
+    size += vn_sizeof_uint32_t(&val->layerCount);
+    return size;
+}
+
+static inline void
+vn_encode_VkImageSubresourceLayers(struct vn_cs_encoder *enc, const VkImageSubresourceLayers *val)
+{
+    vn_encode_VkFlags(enc, &val->aspectMask);
+    vn_encode_uint32_t(enc, &val->mipLevel);
+    vn_encode_uint32_t(enc, &val->baseArrayLayer);
+    vn_encode_uint32_t(enc, &val->layerCount);
+}
+
+/* struct VkImageCopy */
+
+static inline size_t
+vn_sizeof_VkImageCopy(const VkImageCopy *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource);
+    size += vn_sizeof_VkOffset3D(&val->srcOffset);
+    size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource);
+    size += vn_sizeof_VkOffset3D(&val->dstOffset);
+    size += vn_sizeof_VkExtent3D(&val->extent);
+    return size;
+}
+
+static inline void
+vn_encode_VkImageCopy(struct vn_cs_encoder *enc, const VkImageCopy *val)
+{
+    vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource);
+    vn_encode_VkOffset3D(enc, &val->srcOffset);
+    vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource);
+    vn_encode_VkOffset3D(enc, &val->dstOffset);
+    vn_encode_VkExtent3D(enc, &val->extent);
+}
+
+/* struct VkImageBlit */
+
+static inline size_t
+vn_sizeof_VkImageBlit(const VkImageBlit *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource);
+    size += vn_sizeof_array_size(2);
+    for (uint32_t i = 0; i < 2; i++)
+        size += vn_sizeof_VkOffset3D(&val->srcOffsets[i]);
+    size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource);
+    size += vn_sizeof_array_size(2);
+    for (uint32_t i = 0; i < 2; i++)
+        size += vn_sizeof_VkOffset3D(&val->dstOffsets[i]);
+    return size;
+}
+
+static inline void
+vn_encode_VkImageBlit(struct vn_cs_encoder *enc, const VkImageBlit *val)
+{
+    vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource);
+    vn_encode_array_size(enc, 2);
+    for (uint32_t i = 0; i < 2; i++)
+        vn_encode_VkOffset3D(enc, &val->srcOffsets[i]);
+    vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource);
+    vn_encode_array_size(enc, 2);
+    for (uint32_t i = 0; i < 2; i++)
+        vn_encode_VkOffset3D(enc, &val->dstOffsets[i]);
+}
+
+/* struct VkBufferImageCopy */
+
+static inline size_t
+vn_sizeof_VkBufferImageCopy(const VkBufferImageCopy *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkDeviceSize(&val->bufferOffset);
+    size += vn_sizeof_uint32_t(&val->bufferRowLength);
+    size += vn_sizeof_uint32_t(&val->bufferImageHeight);
+    size += vn_sizeof_VkImageSubresourceLayers(&val->imageSubresource);
+    size += vn_sizeof_VkOffset3D(&val->imageOffset);
+    size += vn_sizeof_VkExtent3D(&val->imageExtent);
+    return size;
+}
+
+static inline void
+vn_encode_VkBufferImageCopy(struct vn_cs_encoder *enc, const VkBufferImageCopy *val)
+{
+    vn_encode_VkDeviceSize(enc, &val->bufferOffset);
+    vn_encode_uint32_t(enc, &val->bufferRowLength);
+    vn_encode_uint32_t(enc, &val->bufferImageHeight);
+    vn_encode_VkImageSubresourceLayers(enc, &val->imageSubresource);
+    vn_encode_VkOffset3D(enc, &val->imageOffset);
+    vn_encode_VkExtent3D(enc, &val->imageExtent);
+}
+
+/* union VkClearColorValue */
+
+static inline size_t
+vn_sizeof_VkClearColorValue_tag(const VkClearColorValue *val, uint32_t tag)
+{
+    size_t size = vn_sizeof_uint32_t(&tag);
+    switch (tag) {
+    case 0:
+        size += vn_sizeof_array_size(4);
+    size += vn_sizeof_float_array(val->float32, 4);
+        break;
+    case 1:
+        size += vn_sizeof_array_size(4);
+    size += vn_sizeof_int32_t_array(val->int32, 4);
+        break;
+    case 2:
+        size += vn_sizeof_array_size(4);
+    size += vn_sizeof_uint32_t_array(val->uint32, 4);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkClearColorValue(const VkClearColorValue *val)
+{
+    return vn_sizeof_VkClearColorValue_tag(val, 2);
+}
+
+static inline void
+vn_encode_VkClearColorValue_tag(struct vn_cs_encoder *enc, const VkClearColorValue *val, uint32_t tag)
+{
+    vn_encode_uint32_t(enc, &tag);
+    switch (tag) {
+    case 0:
+        vn_encode_array_size(enc, 4);
+    vn_encode_float_array(enc, val->float32, 4);
+        break;
+    case 1:
+        vn_encode_array_size(enc, 4);
+    vn_encode_int32_t_array(enc, val->int32, 4);
+        break;
+    case 2:
+        vn_encode_array_size(enc, 4);
+    vn_encode_uint32_t_array(enc, val->uint32, 4);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_encode_VkClearColorValue(struct vn_cs_encoder *enc, const VkClearColorValue *val)
+{
+    vn_encode_VkClearColorValue_tag(enc, val, 2); /* union with default tag */
+}
+
+/* struct VkClearDepthStencilValue */
+
+static inline size_t
+vn_sizeof_VkClearDepthStencilValue(const VkClearDepthStencilValue *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_float(&val->depth);
+    size += vn_sizeof_uint32_t(&val->stencil);
+    return size;
+}
+
+static inline void
+vn_encode_VkClearDepthStencilValue(struct vn_cs_encoder *enc, const VkClearDepthStencilValue *val)
+{
+    vn_encode_float(enc, &val->depth);
+    vn_encode_uint32_t(enc, &val->stencil);
+}
+
+/* union VkClearValue */
+
+static inline size_t
+vn_sizeof_VkClearValue_tag(const VkClearValue *val, uint32_t tag)
+{
+    size_t size = vn_sizeof_uint32_t(&tag);
+    switch (tag) {
+    case 0:
+        size += vn_sizeof_VkClearColorValue(&val->color);
+        break;
+    case 1:
+        size += vn_sizeof_VkClearDepthStencilValue(&val->depthStencil);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkClearValue(const VkClearValue *val)
+{
+    return vn_sizeof_VkClearValue_tag(val, 0);
+}
+
+static inline void
+vn_encode_VkClearValue_tag(struct vn_cs_encoder *enc, const VkClearValue *val, uint32_t tag)
+{
+    vn_encode_uint32_t(enc, &tag);
+    switch (tag) {
+    case 0:
+        vn_encode_VkClearColorValue(enc, &val->color);
+        break;
+    case 1:
+        vn_encode_VkClearDepthStencilValue(enc, &val->depthStencil);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_encode_VkClearValue(struct vn_cs_encoder *enc, const VkClearValue *val)
+{
+    vn_encode_VkClearValue_tag(enc, val, 0); /* union with default tag */
+}
+
+/* struct VkClearAttachment */
+
+static inline size_t
+vn_sizeof_VkClearAttachment(const VkClearAttachment *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->aspectMask);
+    size += vn_sizeof_uint32_t(&val->colorAttachment);
+    size += vn_sizeof_VkClearValue(&val->clearValue);
+    return size;
+}
+
+static inline void
+vn_encode_VkClearAttachment(struct vn_cs_encoder *enc, const VkClearAttachment *val)
+{
+    vn_encode_VkFlags(enc, &val->aspectMask);
+    vn_encode_uint32_t(enc, &val->colorAttachment);
+    vn_encode_VkClearValue(enc, &val->clearValue);
+}
+
+/* struct VkClearRect */
+
+static inline size_t
+vn_sizeof_VkClearRect(const VkClearRect *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkRect2D(&val->rect);
+    size += vn_sizeof_uint32_t(&val->baseArrayLayer);
+    size += vn_sizeof_uint32_t(&val->layerCount);
+    return size;
+}
+
+static inline void
+vn_encode_VkClearRect(struct vn_cs_encoder *enc, const VkClearRect *val)
+{
+    vn_encode_VkRect2D(enc, &val->rect);
+    vn_encode_uint32_t(enc, &val->baseArrayLayer);
+    vn_encode_uint32_t(enc, &val->layerCount);
+}
+
+/* struct VkImageResolve */
+
+static inline size_t
+vn_sizeof_VkImageResolve(const VkImageResolve *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource);
+    size += vn_sizeof_VkOffset3D(&val->srcOffset);
+    size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource);
+    size += vn_sizeof_VkOffset3D(&val->dstOffset);
+    size += vn_sizeof_VkExtent3D(&val->extent);
+    return size;
+}
+
+static inline void
+vn_encode_VkImageResolve(struct vn_cs_encoder *enc, const VkImageResolve *val)
+{
+    vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource);
+    vn_encode_VkOffset3D(enc, &val->srcOffset);
+    vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource);
+    vn_encode_VkOffset3D(enc, &val->dstOffset);
+    vn_encode_VkExtent3D(enc, &val->extent);
+}
+
+/* struct VkMemoryBarrier chain */
+
+static inline size_t
+vn_sizeof_VkMemoryBarrier_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkMemoryBarrier_self(const VkMemoryBarrier *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->srcAccessMask);
+    size += vn_sizeof_VkFlags(&val->dstAccessMask);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkMemoryBarrier(const VkMemoryBarrier *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkMemoryBarrier_pnext(val->pNext);
+    size += vn_sizeof_VkMemoryBarrier_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkMemoryBarrier_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkMemoryBarrier_self(struct vn_cs_encoder *enc, const VkMemoryBarrier *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->srcAccessMask);
+    vn_encode_VkFlags(enc, &val->dstAccessMask);
+}
+
+static inline void
+vn_encode_VkMemoryBarrier(struct vn_cs_encoder *enc, const VkMemoryBarrier *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_BARRIER);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_BARRIER });
+    vn_encode_VkMemoryBarrier_pnext(enc, val->pNext);
+    vn_encode_VkMemoryBarrier_self(enc, val);
+}
+
+/* struct VkBufferMemoryBarrier chain */
+
+static inline size_t
+vn_sizeof_VkBufferMemoryBarrier_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBufferMemoryBarrier_self(const VkBufferMemoryBarrier *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->srcAccessMask);
+    size += vn_sizeof_VkFlags(&val->dstAccessMask);
+    size += vn_sizeof_uint32_t(&val->srcQueueFamilyIndex);
+    size += vn_sizeof_uint32_t(&val->dstQueueFamilyIndex);
+    size += vn_sizeof_VkBuffer(&val->buffer);
+    size += vn_sizeof_VkDeviceSize(&val->offset);
+    size += vn_sizeof_VkDeviceSize(&val->size);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBufferMemoryBarrier(const VkBufferMemoryBarrier *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBufferMemoryBarrier_pnext(val->pNext);
+    size += vn_sizeof_VkBufferMemoryBarrier_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBufferMemoryBarrier_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBufferMemoryBarrier_self(struct vn_cs_encoder *enc, const VkBufferMemoryBarrier *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->srcAccessMask);
+    vn_encode_VkFlags(enc, &val->dstAccessMask);
+    vn_encode_uint32_t(enc, &val->srcQueueFamilyIndex);
+    vn_encode_uint32_t(enc, &val->dstQueueFamilyIndex);
+    vn_encode_VkBuffer(enc, &val->buffer);
+    vn_encode_VkDeviceSize(enc, &val->offset);
+    vn_encode_VkDeviceSize(enc, &val->size);
+}
+
+static inline void
+vn_encode_VkBufferMemoryBarrier(struct vn_cs_encoder *enc, const VkBufferMemoryBarrier *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER });
+    vn_encode_VkBufferMemoryBarrier_pnext(enc, val->pNext);
+    vn_encode_VkBufferMemoryBarrier_self(enc, val);
+}
+
+/* struct VkImageMemoryBarrier chain */
+
+static inline size_t
+vn_sizeof_VkImageMemoryBarrier_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageMemoryBarrier_self(const VkImageMemoryBarrier *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->srcAccessMask);
+    size += vn_sizeof_VkFlags(&val->dstAccessMask);
+    size += vn_sizeof_VkImageLayout(&val->oldLayout);
+    size += vn_sizeof_VkImageLayout(&val->newLayout);
+    size += vn_sizeof_uint32_t(&val->srcQueueFamilyIndex);
+    size += vn_sizeof_uint32_t(&val->dstQueueFamilyIndex);
+    size += vn_sizeof_VkImage(&val->image);
+    size += vn_sizeof_VkImageSubresourceRange(&val->subresourceRange);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageMemoryBarrier(const VkImageMemoryBarrier *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageMemoryBarrier_pnext(val->pNext);
+    size += vn_sizeof_VkImageMemoryBarrier_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageMemoryBarrier_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageMemoryBarrier_self(struct vn_cs_encoder *enc, const VkImageMemoryBarrier *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->srcAccessMask);
+    vn_encode_VkFlags(enc, &val->dstAccessMask);
+    vn_encode_VkImageLayout(enc, &val->oldLayout);
+    vn_encode_VkImageLayout(enc, &val->newLayout);
+    vn_encode_uint32_t(enc, &val->srcQueueFamilyIndex);
+    vn_encode_uint32_t(enc, &val->dstQueueFamilyIndex);
+    vn_encode_VkImage(enc, &val->image);
+    vn_encode_VkImageSubresourceRange(enc, &val->subresourceRange);
+}
+
+static inline void
+vn_encode_VkImageMemoryBarrier(struct vn_cs_encoder *enc, const VkImageMemoryBarrier *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER });
+    vn_encode_VkImageMemoryBarrier_pnext(enc, val->pNext);
+    vn_encode_VkImageMemoryBarrier_self(enc, val);
+}
+
+/* struct VkDeviceGroupRenderPassBeginInfo chain */
+
+static inline size_t
+vn_sizeof_VkDeviceGroupRenderPassBeginInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDeviceGroupRenderPassBeginInfo_self(const VkDeviceGroupRenderPassBeginInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->deviceMask);
+    size += vn_sizeof_uint32_t(&val->deviceRenderAreaCount);
+    if (val->pDeviceRenderAreas) {
+        size += vn_sizeof_array_size(val->deviceRenderAreaCount);
+        for (uint32_t i = 0; i < val->deviceRenderAreaCount; i++)
+            size += vn_sizeof_VkRect2D(&val->pDeviceRenderAreas[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDeviceGroupRenderPassBeginInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDeviceGroupRenderPassBeginInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDeviceGroupRenderPassBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDeviceGroupRenderPassBeginInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupRenderPassBeginInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->deviceMask);
+    vn_encode_uint32_t(enc, &val->deviceRenderAreaCount);
+    if (val->pDeviceRenderAreas) {
+        vn_encode_array_size(enc, val->deviceRenderAreaCount);
+        for (uint32_t i = 0; i < val->deviceRenderAreaCount; i++)
+            vn_encode_VkRect2D(enc, &val->pDeviceRenderAreas[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDeviceGroupRenderPassBeginInfo(struct vn_cs_encoder *enc, const VkDeviceGroupRenderPassBeginInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO });
+    vn_encode_VkDeviceGroupRenderPassBeginInfo_pnext(enc, val->pNext);
+    vn_encode_VkDeviceGroupRenderPassBeginInfo_self(enc, val);
+}
+
+/* struct VkRenderPassAttachmentBeginInfo chain */
+
+static inline size_t
+vn_sizeof_VkRenderPassAttachmentBeginInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassAttachmentBeginInfo_self(const VkRenderPassAttachmentBeginInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->attachmentCount);
+    if (val->pAttachments) {
+        size += vn_sizeof_array_size(val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            size += vn_sizeof_VkImageView(&val->pAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkRenderPassAttachmentBeginInfo_pnext(val->pNext);
+    size += vn_sizeof_VkRenderPassAttachmentBeginInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkRenderPassAttachmentBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkRenderPassAttachmentBeginInfo_self(struct vn_cs_encoder *enc, const VkRenderPassAttachmentBeginInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->attachmentCount);
+    if (val->pAttachments) {
+        vn_encode_array_size(enc, val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            vn_encode_VkImageView(enc, &val->pAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkRenderPassAttachmentBeginInfo(struct vn_cs_encoder *enc, const VkRenderPassAttachmentBeginInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO });
+    vn_encode_VkRenderPassAttachmentBeginInfo_pnext(enc, val->pNext);
+    vn_encode_VkRenderPassAttachmentBeginInfo_self(enc, val);
+}
+
+/* struct VkRenderPassBeginInfo chain */
+
+static inline size_t
+vn_sizeof_VkRenderPassBeginInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkRenderPassBeginInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkDeviceGroupRenderPassBeginInfo_self((const VkDeviceGroupRenderPassBeginInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkRenderPassBeginInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkRenderPassAttachmentBeginInfo_self((const VkRenderPassAttachmentBeginInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassBeginInfo_self(const VkRenderPassBeginInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkRenderPass(&val->renderPass);
+    size += vn_sizeof_VkFramebuffer(&val->framebuffer);
+    size += vn_sizeof_VkRect2D(&val->renderArea);
+    size += vn_sizeof_uint32_t(&val->clearValueCount);
+    if (val->pClearValues) {
+        size += vn_sizeof_array_size(val->clearValueCount);
+        for (uint32_t i = 0; i < val->clearValueCount; i++)
+            size += vn_sizeof_VkClearValue(&val->pClearValues[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassBeginInfo(const VkRenderPassBeginInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkRenderPassBeginInfo_pnext(val->pNext);
+    size += vn_sizeof_VkRenderPassBeginInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkRenderPassBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkRenderPassBeginInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkDeviceGroupRenderPassBeginInfo_self(enc, (const VkDeviceGroupRenderPassBeginInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkRenderPassBeginInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkRenderPassAttachmentBeginInfo_self(enc, (const VkRenderPassAttachmentBeginInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkRenderPassBeginInfo_self(struct vn_cs_encoder *enc, const VkRenderPassBeginInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkRenderPass(enc, &val->renderPass);
+    vn_encode_VkFramebuffer(enc, &val->framebuffer);
+    vn_encode_VkRect2D(enc, &val->renderArea);
+    vn_encode_uint32_t(enc, &val->clearValueCount);
+    if (val->pClearValues) {
+        vn_encode_array_size(enc, val->clearValueCount);
+        for (uint32_t i = 0; i < val->clearValueCount; i++)
+            vn_encode_VkClearValue(enc, &val->pClearValues[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkRenderPassBeginInfo(struct vn_cs_encoder *enc, const VkRenderPassBeginInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO });
+    vn_encode_VkRenderPassBeginInfo_pnext(enc, val->pNext);
+    vn_encode_VkRenderPassBeginInfo_self(enc, val);
+}
+
+/* struct VkSubpassBeginInfo chain */
+
+static inline size_t
+vn_sizeof_VkSubpassBeginInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSubpassBeginInfo_self(const VkSubpassBeginInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkSubpassContents(&val->contents);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSubpassBeginInfo(const VkSubpassBeginInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSubpassBeginInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSubpassBeginInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSubpassBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSubpassBeginInfo_self(struct vn_cs_encoder *enc, const VkSubpassBeginInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkSubpassContents(enc, &val->contents);
+}
+
+static inline void
+vn_encode_VkSubpassBeginInfo(struct vn_cs_encoder *enc, const VkSubpassBeginInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO });
+    vn_encode_VkSubpassBeginInfo_pnext(enc, val->pNext);
+    vn_encode_VkSubpassBeginInfo_self(enc, val);
+}
+
+/* struct VkSubpassEndInfo chain */
+
+static inline size_t
+vn_sizeof_VkSubpassEndInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSubpassEndInfo_self(const VkSubpassEndInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSubpassEndInfo(const VkSubpassEndInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSubpassEndInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSubpassEndInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSubpassEndInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSubpassEndInfo_self(struct vn_cs_encoder *enc, const VkSubpassEndInfo *val)
+{
+    /* skip val->{sType,pNext} */
+}
+
+static inline void
+vn_encode_VkSubpassEndInfo(struct vn_cs_encoder *enc, const VkSubpassEndInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_END_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_END_INFO });
+    vn_encode_VkSubpassEndInfo_pnext(enc, val->pNext);
+    vn_encode_VkSubpassEndInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pAllocateInfo);
+    if (pAllocateInfo)
+        cmd_size += vn_sizeof_VkCommandBufferAllocateInfo(pAllocateInfo);
+    if (pCommandBuffers) {
+        cmd_size += vn_sizeof_array_size(pAllocateInfo->commandBufferCount);
+        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++)
+            cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkAllocateCommandBuffers(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pAllocateInfo))
+        vn_encode_VkCommandBufferAllocateInfo(enc, pAllocateInfo);
+    if (pCommandBuffers) {
+        vn_encode_array_size(enc, pAllocateInfo->commandBufferCount);
+        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++)
+            vn_encode_VkCommandBuffer(enc, &pCommandBuffers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkAllocateCommandBuffers_reply(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pAllocateInfo */
+    if (pCommandBuffers) {
+        cmd_size += vn_sizeof_array_size(pAllocateInfo->commandBufferCount);
+        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++)
+            cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkAllocateCommandBuffers_reply(struct vn_cs_decoder *dec, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pAllocateInfo */
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, pAllocateInfo->commandBufferCount);
+        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++)
+            vn_decode_VkCommandBuffer(dec, &pCommandBuffers[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pCommandBuffers = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
+    cmd_size += vn_sizeof_uint32_t(&commandBufferCount);
+    if (pCommandBuffers) {
+        cmd_size += vn_sizeof_array_size(commandBufferCount);
+        for (uint32_t i = 0; i < commandBufferCount; i++)
+            cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkFreeCommandBuffers(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkCommandPool(enc, &commandPool);
+    vn_encode_uint32_t(enc, &commandBufferCount);
+    if (pCommandBuffers) {
+        vn_encode_array_size(enc, commandBufferCount);
+        for (uint32_t i = 0; i < commandBufferCount; i++)
+            vn_encode_VkCommandBuffer(enc, &pCommandBuffers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkFreeCommandBuffers_reply(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip commandPool */
+    /* skip commandBufferCount */
+    /* skip pCommandBuffers */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkFreeCommandBuffers_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT);
+
+    /* skip device */
+    /* skip commandPool */
+    /* skip commandBufferCount */
+    /* skip pCommandBuffers */
+}
+
+static inline size_t vn_sizeof_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_simple_pointer(pBeginInfo);
+    if (pBeginInfo)
+        cmd_size += vn_sizeof_VkCommandBufferBeginInfo(pBeginInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkBeginCommandBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    if (vn_encode_simple_pointer(enc, pBeginInfo))
+        vn_encode_VkCommandBufferBeginInfo(enc, pBeginInfo);
+}
+
+static inline size_t vn_sizeof_vkBeginCommandBuffer_reply(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip commandBuffer */
+    /* skip pBeginInfo */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkBeginCommandBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip commandBuffer */
+    /* skip pBeginInfo */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEndCommandBuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEndCommandBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEndCommandBuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+}
+
+static inline size_t vn_sizeof_vkEndCommandBuffer_reply(VkCommandBuffer commandBuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEndCommandBuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip commandBuffer */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEndCommandBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEndCommandBuffer_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip commandBuffer */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandBuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetCommandBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandBuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkResetCommandBuffer_reply(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandBuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip commandBuffer */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkResetCommandBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetCommandBuffer_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip commandBuffer */
+    /* skip flags */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindPipeline_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkPipelineBindPoint(&pipelineBindPoint);
+    cmd_size += vn_sizeof_VkPipeline(&pipeline);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBindPipeline(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindPipeline_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkPipelineBindPoint(enc, &pipelineBindPoint);
+    vn_encode_VkPipeline(enc, &pipeline);
+}
+
+static inline size_t vn_sizeof_vkCmdBindPipeline_reply(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindPipeline_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip pipelineBindPoint */
+    /* skip pipeline */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBindPipeline_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBindPipeline_EXT);
+
+    /* skip commandBuffer */
+    /* skip pipelineBindPoint */
+    /* skip pipeline */
+}
+
+static inline size_t vn_sizeof_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewport_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&firstViewport);
+    cmd_size += vn_sizeof_uint32_t(&viewportCount);
+    if (pViewports) {
+        cmd_size += vn_sizeof_array_size(viewportCount);
+        for (uint32_t i = 0; i < viewportCount; i++)
+            cmd_size += vn_sizeof_VkViewport(&pViewports[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetViewport(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewport_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &firstViewport);
+    vn_encode_uint32_t(enc, &viewportCount);
+    if (pViewports) {
+        vn_encode_array_size(enc, viewportCount);
+        for (uint32_t i = 0; i < viewportCount; i++)
+            vn_encode_VkViewport(enc, &pViewports[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdSetViewport_reply(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewport_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip firstViewport */
+    /* skip viewportCount */
+    /* skip pViewports */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetViewport_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetViewport_EXT);
+
+    /* skip commandBuffer */
+    /* skip firstViewport */
+    /* skip viewportCount */
+    /* skip pViewports */
+}
+
+static inline size_t vn_sizeof_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissor_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&firstScissor);
+    cmd_size += vn_sizeof_uint32_t(&scissorCount);
+    if (pScissors) {
+        cmd_size += vn_sizeof_array_size(scissorCount);
+        for (uint32_t i = 0; i < scissorCount; i++)
+            cmd_size += vn_sizeof_VkRect2D(&pScissors[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetScissor(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissor_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &firstScissor);
+    vn_encode_uint32_t(enc, &scissorCount);
+    if (pScissors) {
+        vn_encode_array_size(enc, scissorCount);
+        for (uint32_t i = 0; i < scissorCount; i++)
+            vn_encode_VkRect2D(enc, &pScissors[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdSetScissor_reply(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissor_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip firstScissor */
+    /* skip scissorCount */
+    /* skip pScissors */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetScissor_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetScissor_EXT);
+
+    /* skip commandBuffer */
+    /* skip firstScissor */
+    /* skip scissorCount */
+    /* skip pScissors */
+}
+
+static inline size_t vn_sizeof_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_float(&lineWidth);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetLineWidth(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float lineWidth)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_float(enc, &lineWidth);
+}
+
+static inline size_t vn_sizeof_vkCmdSetLineWidth_reply(VkCommandBuffer commandBuffer, float lineWidth)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip lineWidth */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetLineWidth_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, float lineWidth)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT);
+
+    /* skip commandBuffer */
+    /* skip lineWidth */
+}
+
+static inline size_t vn_sizeof_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_float(&depthBiasConstantFactor);
+    cmd_size += vn_sizeof_float(&depthBiasClamp);
+    cmd_size += vn_sizeof_float(&depthBiasSlopeFactor);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetDepthBias(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_float(enc, &depthBiasConstantFactor);
+    vn_encode_float(enc, &depthBiasClamp);
+    vn_encode_float(enc, &depthBiasSlopeFactor);
+}
+
+static inline size_t vn_sizeof_vkCmdSetDepthBias_reply(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip depthBiasConstantFactor */
+    /* skip depthBiasClamp */
+    /* skip depthBiasSlopeFactor */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetDepthBias_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT);
+
+    /* skip commandBuffer */
+    /* skip depthBiasConstantFactor */
+    /* skip depthBiasClamp */
+    /* skip depthBiasSlopeFactor */
+}
+
+static inline size_t vn_sizeof_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_array_size(4);
+    cmd_size += vn_sizeof_float_array(blendConstants, 4);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetBlendConstants(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const float blendConstants[4])
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_array_size(enc, 4);
+    vn_encode_float_array(enc, blendConstants, 4);
+}
+
+static inline size_t vn_sizeof_vkCmdSetBlendConstants_reply(VkCommandBuffer commandBuffer, const float blendConstants[4])
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip blendConstants */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetBlendConstants_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const float blendConstants[4])
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT);
+
+    /* skip commandBuffer */
+    /* skip blendConstants */
+}
+
+static inline size_t vn_sizeof_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_float(&minDepthBounds);
+    cmd_size += vn_sizeof_float(&maxDepthBounds);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetDepthBounds(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_float(enc, &minDepthBounds);
+    vn_encode_float(enc, &maxDepthBounds);
+}
+
+static inline size_t vn_sizeof_vkCmdSetDepthBounds_reply(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip minDepthBounds */
+    /* skip maxDepthBounds */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetDepthBounds_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT);
+
+    /* skip commandBuffer */
+    /* skip minDepthBounds */
+    /* skip maxDepthBounds */
+}
+
+static inline size_t vn_sizeof_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkFlags(&faceMask);
+    cmd_size += vn_sizeof_uint32_t(&compareMask);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetStencilCompareMask(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkFlags(enc, &faceMask);
+    vn_encode_uint32_t(enc, &compareMask);
+}
+
+static inline size_t vn_sizeof_vkCmdSetStencilCompareMask_reply(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip faceMask */
+    /* skip compareMask */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetStencilCompareMask_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT);
+
+    /* skip commandBuffer */
+    /* skip faceMask */
+    /* skip compareMask */
+}
+
+static inline size_t vn_sizeof_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkFlags(&faceMask);
+    cmd_size += vn_sizeof_uint32_t(&writeMask);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetStencilWriteMask(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkFlags(enc, &faceMask);
+    vn_encode_uint32_t(enc, &writeMask);
+}
+
+static inline size_t vn_sizeof_vkCmdSetStencilWriteMask_reply(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip faceMask */
+    /* skip writeMask */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetStencilWriteMask_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT);
+
+    /* skip commandBuffer */
+    /* skip faceMask */
+    /* skip writeMask */
+}
+
+static inline size_t vn_sizeof_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkFlags(&faceMask);
+    cmd_size += vn_sizeof_uint32_t(&reference);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetStencilReference(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkFlags(enc, &faceMask);
+    vn_encode_uint32_t(enc, &reference);
+}
+
+static inline size_t vn_sizeof_vkCmdSetStencilReference_reply(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip faceMask */
+    /* skip reference */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetStencilReference_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT);
+
+    /* skip commandBuffer */
+    /* skip faceMask */
+    /* skip reference */
+}
+
+static inline size_t vn_sizeof_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkPipelineBindPoint(&pipelineBindPoint);
+    cmd_size += vn_sizeof_VkPipelineLayout(&layout);
+    cmd_size += vn_sizeof_uint32_t(&firstSet);
+    cmd_size += vn_sizeof_uint32_t(&descriptorSetCount);
+    if (pDescriptorSets) {
+        cmd_size += vn_sizeof_array_size(descriptorSetCount);
+        for (uint32_t i = 0; i < descriptorSetCount; i++)
+            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_uint32_t(&dynamicOffsetCount);
+    if (pDynamicOffsets) {
+        cmd_size += vn_sizeof_array_size(dynamicOffsetCount);
+        cmd_size += vn_sizeof_uint32_t_array(pDynamicOffsets, dynamicOffsetCount);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBindDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkPipelineBindPoint(enc, &pipelineBindPoint);
+    vn_encode_VkPipelineLayout(enc, &layout);
+    vn_encode_uint32_t(enc, &firstSet);
+    vn_encode_uint32_t(enc, &descriptorSetCount);
+    if (pDescriptorSets) {
+        vn_encode_array_size(enc, descriptorSetCount);
+        for (uint32_t i = 0; i < descriptorSetCount; i++)
+            vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &dynamicOffsetCount);
+    if (pDynamicOffsets) {
+        vn_encode_array_size(enc, dynamicOffsetCount);
+        vn_encode_uint32_t_array(enc, pDynamicOffsets, dynamicOffsetCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdBindDescriptorSets_reply(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip pipelineBindPoint */
+    /* skip layout */
+    /* skip firstSet */
+    /* skip descriptorSetCount */
+    /* skip pDescriptorSets */
+    /* skip dynamicOffsetCount */
+    /* skip pDynamicOffsets */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBindDescriptorSets_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT);
+
+    /* skip commandBuffer */
+    /* skip pipelineBindPoint */
+    /* skip layout */
+    /* skip firstSet */
+    /* skip descriptorSetCount */
+    /* skip pDescriptorSets */
+    /* skip dynamicOffsetCount */
+    /* skip pDynamicOffsets */
+}
+
+static inline size_t vn_sizeof_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&buffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&offset);
+    cmd_size += vn_sizeof_VkIndexType(&indexType);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBindIndexBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkBuffer(enc, &buffer);
+    vn_encode_VkDeviceSize(enc, &offset);
+    vn_encode_VkIndexType(enc, &indexType);
+}
+
+static inline size_t vn_sizeof_vkCmdBindIndexBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+    /* skip indexType */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBindIndexBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+    /* skip indexType */
+}
+
+static inline size_t vn_sizeof_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&firstBinding);
+    cmd_size += vn_sizeof_uint32_t(&bindingCount);
+    if (pBuffers) {
+        cmd_size += vn_sizeof_array_size(bindingCount);
+        for (uint32_t i = 0; i < bindingCount; i++)
+            cmd_size += vn_sizeof_VkBuffer(&pBuffers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    if (pOffsets) {
+        cmd_size += vn_sizeof_array_size(bindingCount);
+        cmd_size += vn_sizeof_VkDeviceSize_array(pOffsets, bindingCount);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBindVertexBuffers(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &firstBinding);
+    vn_encode_uint32_t(enc, &bindingCount);
+    if (pBuffers) {
+        vn_encode_array_size(enc, bindingCount);
+        for (uint32_t i = 0; i < bindingCount; i++)
+            vn_encode_VkBuffer(enc, &pBuffers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (pOffsets) {
+        vn_encode_array_size(enc, bindingCount);
+        vn_encode_VkDeviceSize_array(enc, pOffsets, bindingCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdBindVertexBuffers_reply(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip firstBinding */
+    /* skip bindingCount */
+    /* skip pBuffers */
+    /* skip pOffsets */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBindVertexBuffers_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT);
+
+    /* skip commandBuffer */
+    /* skip firstBinding */
+    /* skip bindingCount */
+    /* skip pBuffers */
+    /* skip pOffsets */
+}
+
+static inline size_t vn_sizeof_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDraw_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&vertexCount);
+    cmd_size += vn_sizeof_uint32_t(&instanceCount);
+    cmd_size += vn_sizeof_uint32_t(&firstVertex);
+    cmd_size += vn_sizeof_uint32_t(&firstInstance);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdDraw(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDraw_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &vertexCount);
+    vn_encode_uint32_t(enc, &instanceCount);
+    vn_encode_uint32_t(enc, &firstVertex);
+    vn_encode_uint32_t(enc, &firstInstance);
+}
+
+static inline size_t vn_sizeof_vkCmdDraw_reply(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDraw_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip vertexCount */
+    /* skip instanceCount */
+    /* skip firstVertex */
+    /* skip firstInstance */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdDraw_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdDraw_EXT);
+
+    /* skip commandBuffer */
+    /* skip vertexCount */
+    /* skip instanceCount */
+    /* skip firstVertex */
+    /* skip firstInstance */
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&indexCount);
+    cmd_size += vn_sizeof_uint32_t(&instanceCount);
+    cmd_size += vn_sizeof_uint32_t(&firstIndex);
+    cmd_size += vn_sizeof_int32_t(&vertexOffset);
+    cmd_size += vn_sizeof_uint32_t(&firstInstance);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdDrawIndexed(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &indexCount);
+    vn_encode_uint32_t(enc, &instanceCount);
+    vn_encode_uint32_t(enc, &firstIndex);
+    vn_encode_int32_t(enc, &vertexOffset);
+    vn_encode_uint32_t(enc, &firstInstance);
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndexed_reply(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip indexCount */
+    /* skip instanceCount */
+    /* skip firstIndex */
+    /* skip vertexOffset */
+    /* skip firstInstance */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdDrawIndexed_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT);
+
+    /* skip commandBuffer */
+    /* skip indexCount */
+    /* skip instanceCount */
+    /* skip firstIndex */
+    /* skip vertexOffset */
+    /* skip firstInstance */
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&buffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&offset);
+    cmd_size += vn_sizeof_uint32_t(&drawCount);
+    cmd_size += vn_sizeof_uint32_t(&stride);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdDrawIndirect(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkBuffer(enc, &buffer);
+    vn_encode_VkDeviceSize(enc, &offset);
+    vn_encode_uint32_t(enc, &drawCount);
+    vn_encode_uint32_t(enc, &stride);
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndirect_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+    /* skip drawCount */
+    /* skip stride */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdDrawIndirect_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+    /* skip drawCount */
+    /* skip stride */
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&buffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&offset);
+    cmd_size += vn_sizeof_uint32_t(&drawCount);
+    cmd_size += vn_sizeof_uint32_t(&stride);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdDrawIndexedIndirect(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkBuffer(enc, &buffer);
+    vn_encode_VkDeviceSize(enc, &offset);
+    vn_encode_uint32_t(enc, &drawCount);
+    vn_encode_uint32_t(enc, &stride);
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndexedIndirect_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+    /* skip drawCount */
+    /* skip stride */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdDrawIndexedIndirect_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+    /* skip drawCount */
+    /* skip stride */
+}
+
+static inline size_t vn_sizeof_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatch_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&groupCountX);
+    cmd_size += vn_sizeof_uint32_t(&groupCountY);
+    cmd_size += vn_sizeof_uint32_t(&groupCountZ);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdDispatch(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatch_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &groupCountX);
+    vn_encode_uint32_t(enc, &groupCountY);
+    vn_encode_uint32_t(enc, &groupCountZ);
+}
+
+static inline size_t vn_sizeof_vkCmdDispatch_reply(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatch_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip groupCountX */
+    /* skip groupCountY */
+    /* skip groupCountZ */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdDispatch_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdDispatch_EXT);
+
+    /* skip commandBuffer */
+    /* skip groupCountX */
+    /* skip groupCountY */
+    /* skip groupCountZ */
+}
+
+static inline size_t vn_sizeof_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&buffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&offset);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdDispatchIndirect(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkBuffer(enc, &buffer);
+    vn_encode_VkDeviceSize(enc, &offset);
+}
+
+static inline size_t vn_sizeof_vkCmdDispatchIndirect_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdDispatchIndirect_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+}
+
+static inline size_t vn_sizeof_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&srcBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&dstBuffer);
+    cmd_size += vn_sizeof_uint32_t(&regionCount);
+    if (pRegions) {
+        cmd_size += vn_sizeof_array_size(regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            cmd_size += vn_sizeof_VkBufferCopy(&pRegions[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdCopyBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkBuffer(enc, &srcBuffer);
+    vn_encode_VkBuffer(enc, &dstBuffer);
+    vn_encode_uint32_t(enc, &regionCount);
+    if (pRegions) {
+        vn_encode_array_size(enc, regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            vn_encode_VkBufferCopy(enc, &pRegions[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdCopyBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip srcBuffer */
+    /* skip dstBuffer */
+    /* skip regionCount */
+    /* skip pRegions */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdCopyBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT);
+
+    /* skip commandBuffer */
+    /* skip srcBuffer */
+    /* skip dstBuffer */
+    /* skip regionCount */
+    /* skip pRegions */
+}
+
+static inline size_t vn_sizeof_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkImage(&srcImage);
+    cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout);
+    cmd_size += vn_sizeof_VkImage(&dstImage);
+    cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout);
+    cmd_size += vn_sizeof_uint32_t(&regionCount);
+    if (pRegions) {
+        cmd_size += vn_sizeof_array_size(regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            cmd_size += vn_sizeof_VkImageCopy(&pRegions[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdCopyImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkImage(enc, &srcImage);
+    vn_encode_VkImageLayout(enc, &srcImageLayout);
+    vn_encode_VkImage(enc, &dstImage);
+    vn_encode_VkImageLayout(enc, &dstImageLayout);
+    vn_encode_uint32_t(enc, &regionCount);
+    if (pRegions) {
+        vn_encode_array_size(enc, regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            vn_encode_VkImageCopy(enc, &pRegions[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdCopyImage_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip srcImage */
+    /* skip srcImageLayout */
+    /* skip dstImage */
+    /* skip dstImageLayout */
+    /* skip regionCount */
+    /* skip pRegions */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdCopyImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdCopyImage_EXT);
+
+    /* skip commandBuffer */
+    /* skip srcImage */
+    /* skip srcImageLayout */
+    /* skip dstImage */
+    /* skip dstImageLayout */
+    /* skip regionCount */
+    /* skip pRegions */
+}
+
+static inline size_t vn_sizeof_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkImage(&srcImage);
+    cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout);
+    cmd_size += vn_sizeof_VkImage(&dstImage);
+    cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout);
+    cmd_size += vn_sizeof_uint32_t(&regionCount);
+    if (pRegions) {
+        cmd_size += vn_sizeof_array_size(regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            cmd_size += vn_sizeof_VkImageBlit(&pRegions[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_VkFilter(&filter);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBlitImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkImage(enc, &srcImage);
+    vn_encode_VkImageLayout(enc, &srcImageLayout);
+    vn_encode_VkImage(enc, &dstImage);
+    vn_encode_VkImageLayout(enc, &dstImageLayout);
+    vn_encode_uint32_t(enc, &regionCount);
+    if (pRegions) {
+        vn_encode_array_size(enc, regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            vn_encode_VkImageBlit(enc, &pRegions[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkFilter(enc, &filter);
+}
+
+static inline size_t vn_sizeof_vkCmdBlitImage_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip srcImage */
+    /* skip srcImageLayout */
+    /* skip dstImage */
+    /* skip dstImageLayout */
+    /* skip regionCount */
+    /* skip pRegions */
+    /* skip filter */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBlitImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBlitImage_EXT);
+
+    /* skip commandBuffer */
+    /* skip srcImage */
+    /* skip srcImageLayout */
+    /* skip dstImage */
+    /* skip dstImageLayout */
+    /* skip regionCount */
+    /* skip pRegions */
+    /* skip filter */
+}
+
+static inline size_t vn_sizeof_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&srcBuffer);
+    cmd_size += vn_sizeof_VkImage(&dstImage);
+    cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout);
+    cmd_size += vn_sizeof_uint32_t(&regionCount);
+    if (pRegions) {
+        cmd_size += vn_sizeof_array_size(regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            cmd_size += vn_sizeof_VkBufferImageCopy(&pRegions[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdCopyBufferToImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkBuffer(enc, &srcBuffer);
+    vn_encode_VkImage(enc, &dstImage);
+    vn_encode_VkImageLayout(enc, &dstImageLayout);
+    vn_encode_uint32_t(enc, &regionCount);
+    if (pRegions) {
+        vn_encode_array_size(enc, regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            vn_encode_VkBufferImageCopy(enc, &pRegions[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdCopyBufferToImage_reply(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip srcBuffer */
+    /* skip dstImage */
+    /* skip dstImageLayout */
+    /* skip regionCount */
+    /* skip pRegions */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdCopyBufferToImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT);
+
+    /* skip commandBuffer */
+    /* skip srcBuffer */
+    /* skip dstImage */
+    /* skip dstImageLayout */
+    /* skip regionCount */
+    /* skip pRegions */
+}
+
+static inline size_t vn_sizeof_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkImage(&srcImage);
+    cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout);
+    cmd_size += vn_sizeof_VkBuffer(&dstBuffer);
+    cmd_size += vn_sizeof_uint32_t(&regionCount);
+    if (pRegions) {
+        cmd_size += vn_sizeof_array_size(regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            cmd_size += vn_sizeof_VkBufferImageCopy(&pRegions[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdCopyImageToBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkImage(enc, &srcImage);
+    vn_encode_VkImageLayout(enc, &srcImageLayout);
+    vn_encode_VkBuffer(enc, &dstBuffer);
+    vn_encode_uint32_t(enc, &regionCount);
+    if (pRegions) {
+        vn_encode_array_size(enc, regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            vn_encode_VkBufferImageCopy(enc, &pRegions[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdCopyImageToBuffer_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip srcImage */
+    /* skip srcImageLayout */
+    /* skip dstBuffer */
+    /* skip regionCount */
+    /* skip pRegions */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdCopyImageToBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT);
+
+    /* skip commandBuffer */
+    /* skip srcImage */
+    /* skip srcImageLayout */
+    /* skip dstBuffer */
+    /* skip regionCount */
+    /* skip pRegions */
+}
+
+static inline size_t vn_sizeof_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&dstBuffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&dstOffset);
+    cmd_size += vn_sizeof_VkDeviceSize(&dataSize);
+    if (pData) {
+        cmd_size += vn_sizeof_array_size(dataSize);
+        cmd_size += vn_sizeof_blob_array(pData, dataSize);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdUpdateBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkBuffer(enc, &dstBuffer);
+    vn_encode_VkDeviceSize(enc, &dstOffset);
+    vn_encode_VkDeviceSize(enc, &dataSize);
+    if (pData) {
+        vn_encode_array_size(enc, dataSize);
+        vn_encode_blob_array(enc, pData, dataSize);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdUpdateBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip dstBuffer */
+    /* skip dstOffset */
+    /* skip dataSize */
+    /* skip pData */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdUpdateBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT);
+
+    /* skip commandBuffer */
+    /* skip dstBuffer */
+    /* skip dstOffset */
+    /* skip dataSize */
+    /* skip pData */
+}
+
+static inline size_t vn_sizeof_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdFillBuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&dstBuffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&dstOffset);
+    cmd_size += vn_sizeof_VkDeviceSize(&size);
+    cmd_size += vn_sizeof_uint32_t(&data);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdFillBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdFillBuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkBuffer(enc, &dstBuffer);
+    vn_encode_VkDeviceSize(enc, &dstOffset);
+    vn_encode_VkDeviceSize(enc, &size);
+    vn_encode_uint32_t(enc, &data);
+}
+
+static inline size_t vn_sizeof_vkCmdFillBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdFillBuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip dstBuffer */
+    /* skip dstOffset */
+    /* skip size */
+    /* skip data */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdFillBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdFillBuffer_EXT);
+
+    /* skip commandBuffer */
+    /* skip dstBuffer */
+    /* skip dstOffset */
+    /* skip size */
+    /* skip data */
+}
+
+static inline size_t vn_sizeof_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearColorImage_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkImage(&image);
+    cmd_size += vn_sizeof_VkImageLayout(&imageLayout);
+    cmd_size += vn_sizeof_simple_pointer(pColor);
+    if (pColor)
+        cmd_size += vn_sizeof_VkClearColorValue(pColor);
+    cmd_size += vn_sizeof_uint32_t(&rangeCount);
+    if (pRanges) {
+        cmd_size += vn_sizeof_array_size(rangeCount);
+        for (uint32_t i = 0; i < rangeCount; i++)
+            cmd_size += vn_sizeof_VkImageSubresourceRange(&pRanges[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdClearColorImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearColorImage_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkImage(enc, &image);
+    vn_encode_VkImageLayout(enc, &imageLayout);
+    if (vn_encode_simple_pointer(enc, pColor))
+        vn_encode_VkClearColorValue(enc, pColor);
+    vn_encode_uint32_t(enc, &rangeCount);
+    if (pRanges) {
+        vn_encode_array_size(enc, rangeCount);
+        for (uint32_t i = 0; i < rangeCount; i++)
+            vn_encode_VkImageSubresourceRange(enc, &pRanges[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdClearColorImage_reply(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearColorImage_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip image */
+    /* skip imageLayout */
+    /* skip pColor */
+    /* skip rangeCount */
+    /* skip pRanges */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdClearColorImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdClearColorImage_EXT);
+
+    /* skip commandBuffer */
+    /* skip image */
+    /* skip imageLayout */
+    /* skip pColor */
+    /* skip rangeCount */
+    /* skip pRanges */
+}
+
+static inline size_t vn_sizeof_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkImage(&image);
+    cmd_size += vn_sizeof_VkImageLayout(&imageLayout);
+    cmd_size += vn_sizeof_simple_pointer(pDepthStencil);
+    if (pDepthStencil)
+        cmd_size += vn_sizeof_VkClearDepthStencilValue(pDepthStencil);
+    cmd_size += vn_sizeof_uint32_t(&rangeCount);
+    if (pRanges) {
+        cmd_size += vn_sizeof_array_size(rangeCount);
+        for (uint32_t i = 0; i < rangeCount; i++)
+            cmd_size += vn_sizeof_VkImageSubresourceRange(&pRanges[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdClearDepthStencilImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkImage(enc, &image);
+    vn_encode_VkImageLayout(enc, &imageLayout);
+    if (vn_encode_simple_pointer(enc, pDepthStencil))
+        vn_encode_VkClearDepthStencilValue(enc, pDepthStencil);
+    vn_encode_uint32_t(enc, &rangeCount);
+    if (pRanges) {
+        vn_encode_array_size(enc, rangeCount);
+        for (uint32_t i = 0; i < rangeCount; i++)
+            vn_encode_VkImageSubresourceRange(enc, &pRanges[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdClearDepthStencilImage_reply(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip image */
+    /* skip imageLayout */
+    /* skip pDepthStencil */
+    /* skip rangeCount */
+    /* skip pRanges */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdClearDepthStencilImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT);
+
+    /* skip commandBuffer */
+    /* skip image */
+    /* skip imageLayout */
+    /* skip pDepthStencil */
+    /* skip rangeCount */
+    /* skip pRanges */
+}
+
+static inline size_t vn_sizeof_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearAttachments_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&attachmentCount);
+    if (pAttachments) {
+        cmd_size += vn_sizeof_array_size(attachmentCount);
+        for (uint32_t i = 0; i < attachmentCount; i++)
+            cmd_size += vn_sizeof_VkClearAttachment(&pAttachments[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_uint32_t(&rectCount);
+    if (pRects) {
+        cmd_size += vn_sizeof_array_size(rectCount);
+        for (uint32_t i = 0; i < rectCount; i++)
+            cmd_size += vn_sizeof_VkClearRect(&pRects[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdClearAttachments(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearAttachments_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &attachmentCount);
+    if (pAttachments) {
+        vn_encode_array_size(enc, attachmentCount);
+        for (uint32_t i = 0; i < attachmentCount; i++)
+            vn_encode_VkClearAttachment(enc, &pAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &rectCount);
+    if (pRects) {
+        vn_encode_array_size(enc, rectCount);
+        for (uint32_t i = 0; i < rectCount; i++)
+            vn_encode_VkClearRect(enc, &pRects[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdClearAttachments_reply(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearAttachments_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip attachmentCount */
+    /* skip pAttachments */
+    /* skip rectCount */
+    /* skip pRects */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdClearAttachments_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdClearAttachments_EXT);
+
+    /* skip commandBuffer */
+    /* skip attachmentCount */
+    /* skip pAttachments */
+    /* skip rectCount */
+    /* skip pRects */
+}
+
+static inline size_t vn_sizeof_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkImage(&srcImage);
+    cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout);
+    cmd_size += vn_sizeof_VkImage(&dstImage);
+    cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout);
+    cmd_size += vn_sizeof_uint32_t(&regionCount);
+    if (pRegions) {
+        cmd_size += vn_sizeof_array_size(regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            cmd_size += vn_sizeof_VkImageResolve(&pRegions[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdResolveImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkImage(enc, &srcImage);
+    vn_encode_VkImageLayout(enc, &srcImageLayout);
+    vn_encode_VkImage(enc, &dstImage);
+    vn_encode_VkImageLayout(enc, &dstImageLayout);
+    vn_encode_uint32_t(enc, &regionCount);
+    if (pRegions) {
+        vn_encode_array_size(enc, regionCount);
+        for (uint32_t i = 0; i < regionCount; i++)
+            vn_encode_VkImageResolve(enc, &pRegions[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdResolveImage_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip srcImage */
+    /* skip srcImageLayout */
+    /* skip dstImage */
+    /* skip dstImageLayout */
+    /* skip regionCount */
+    /* skip pRegions */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdResolveImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdResolveImage_EXT);
+
+    /* skip commandBuffer */
+    /* skip srcImage */
+    /* skip srcImageLayout */
+    /* skip dstImage */
+    /* skip dstImageLayout */
+    /* skip regionCount */
+    /* skip pRegions */
+}
+
+static inline size_t vn_sizeof_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkEvent(&event);
+    cmd_size += vn_sizeof_VkFlags(&stageMask);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkEvent(enc, &event);
+    vn_encode_VkFlags(enc, &stageMask);
+}
+
+static inline size_t vn_sizeof_vkCmdSetEvent_reply(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip event */
+    /* skip stageMask */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetEvent_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetEvent_EXT);
+
+    /* skip commandBuffer */
+    /* skip event */
+    /* skip stageMask */
+}
+
+static inline size_t vn_sizeof_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkEvent(&event);
+    cmd_size += vn_sizeof_VkFlags(&stageMask);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdResetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkEvent(enc, &event);
+    vn_encode_VkFlags(enc, &stageMask);
+}
+
+static inline size_t vn_sizeof_vkCmdResetEvent_reply(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip event */
+    /* skip stageMask */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdResetEvent_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdResetEvent_EXT);
+
+    /* skip commandBuffer */
+    /* skip event */
+    /* skip stageMask */
+}
+
+static inline size_t vn_sizeof_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&eventCount);
+    if (pEvents) {
+        cmd_size += vn_sizeof_array_size(eventCount);
+        for (uint32_t i = 0; i < eventCount; i++)
+            cmd_size += vn_sizeof_VkEvent(&pEvents[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_VkFlags(&srcStageMask);
+    cmd_size += vn_sizeof_VkFlags(&dstStageMask);
+    cmd_size += vn_sizeof_uint32_t(&memoryBarrierCount);
+    if (pMemoryBarriers) {
+        cmd_size += vn_sizeof_array_size(memoryBarrierCount);
+        for (uint32_t i = 0; i < memoryBarrierCount; i++)
+            cmd_size += vn_sizeof_VkMemoryBarrier(&pMemoryBarriers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_uint32_t(&bufferMemoryBarrierCount);
+    if (pBufferMemoryBarriers) {
+        cmd_size += vn_sizeof_array_size(bufferMemoryBarrierCount);
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++)
+            cmd_size += vn_sizeof_VkBufferMemoryBarrier(&pBufferMemoryBarriers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_uint32_t(&imageMemoryBarrierCount);
+    if (pImageMemoryBarriers) {
+        cmd_size += vn_sizeof_array_size(imageMemoryBarrierCount);
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; i++)
+            cmd_size += vn_sizeof_VkImageMemoryBarrier(&pImageMemoryBarriers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdWaitEvents(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &eventCount);
+    if (pEvents) {
+        vn_encode_array_size(enc, eventCount);
+        for (uint32_t i = 0; i < eventCount; i++)
+            vn_encode_VkEvent(enc, &pEvents[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkFlags(enc, &srcStageMask);
+    vn_encode_VkFlags(enc, &dstStageMask);
+    vn_encode_uint32_t(enc, &memoryBarrierCount);
+    if (pMemoryBarriers) {
+        vn_encode_array_size(enc, memoryBarrierCount);
+        for (uint32_t i = 0; i < memoryBarrierCount; i++)
+            vn_encode_VkMemoryBarrier(enc, &pMemoryBarriers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &bufferMemoryBarrierCount);
+    if (pBufferMemoryBarriers) {
+        vn_encode_array_size(enc, bufferMemoryBarrierCount);
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++)
+            vn_encode_VkBufferMemoryBarrier(enc, &pBufferMemoryBarriers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &imageMemoryBarrierCount);
+    if (pImageMemoryBarriers) {
+        vn_encode_array_size(enc, imageMemoryBarrierCount);
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; i++)
+            vn_encode_VkImageMemoryBarrier(enc, &pImageMemoryBarriers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdWaitEvents_reply(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip eventCount */
+    /* skip pEvents */
+    /* skip srcStageMask */
+    /* skip dstStageMask */
+    /* skip memoryBarrierCount */
+    /* skip pMemoryBarriers */
+    /* skip bufferMemoryBarrierCount */
+    /* skip pBufferMemoryBarriers */
+    /* skip imageMemoryBarrierCount */
+    /* skip pImageMemoryBarriers */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdWaitEvents_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdWaitEvents_EXT);
+
+    /* skip commandBuffer */
+    /* skip eventCount */
+    /* skip pEvents */
+    /* skip srcStageMask */
+    /* skip dstStageMask */
+    /* skip memoryBarrierCount */
+    /* skip pMemoryBarriers */
+    /* skip bufferMemoryBarrierCount */
+    /* skip pBufferMemoryBarriers */
+    /* skip imageMemoryBarrierCount */
+    /* skip pImageMemoryBarriers */
+}
+
+static inline size_t vn_sizeof_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkFlags(&srcStageMask);
+    cmd_size += vn_sizeof_VkFlags(&dstStageMask);
+    cmd_size += vn_sizeof_VkFlags(&dependencyFlags);
+    cmd_size += vn_sizeof_uint32_t(&memoryBarrierCount);
+    if (pMemoryBarriers) {
+        cmd_size += vn_sizeof_array_size(memoryBarrierCount);
+        for (uint32_t i = 0; i < memoryBarrierCount; i++)
+            cmd_size += vn_sizeof_VkMemoryBarrier(&pMemoryBarriers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_uint32_t(&bufferMemoryBarrierCount);
+    if (pBufferMemoryBarriers) {
+        cmd_size += vn_sizeof_array_size(bufferMemoryBarrierCount);
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++)
+            cmd_size += vn_sizeof_VkBufferMemoryBarrier(&pBufferMemoryBarriers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_uint32_t(&imageMemoryBarrierCount);
+    if (pImageMemoryBarriers) {
+        cmd_size += vn_sizeof_array_size(imageMemoryBarrierCount);
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; i++)
+            cmd_size += vn_sizeof_VkImageMemoryBarrier(&pImageMemoryBarriers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdPipelineBarrier(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkFlags(enc, &srcStageMask);
+    vn_encode_VkFlags(enc, &dstStageMask);
+    vn_encode_VkFlags(enc, &dependencyFlags);
+    vn_encode_uint32_t(enc, &memoryBarrierCount);
+    if (pMemoryBarriers) {
+        vn_encode_array_size(enc, memoryBarrierCount);
+        for (uint32_t i = 0; i < memoryBarrierCount; i++)
+            vn_encode_VkMemoryBarrier(enc, &pMemoryBarriers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &bufferMemoryBarrierCount);
+    if (pBufferMemoryBarriers) {
+        vn_encode_array_size(enc, bufferMemoryBarrierCount);
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++)
+            vn_encode_VkBufferMemoryBarrier(enc, &pBufferMemoryBarriers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &imageMemoryBarrierCount);
+    if (pImageMemoryBarriers) {
+        vn_encode_array_size(enc, imageMemoryBarrierCount);
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; i++)
+            vn_encode_VkImageMemoryBarrier(enc, &pImageMemoryBarriers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdPipelineBarrier_reply(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip srcStageMask */
+    /* skip dstStageMask */
+    /* skip dependencyFlags */
+    /* skip memoryBarrierCount */
+    /* skip pMemoryBarriers */
+    /* skip bufferMemoryBarrierCount */
+    /* skip pBufferMemoryBarriers */
+    /* skip imageMemoryBarrierCount */
+    /* skip pImageMemoryBarriers */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdPipelineBarrier_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT);
+
+    /* skip commandBuffer */
+    /* skip srcStageMask */
+    /* skip dstStageMask */
+    /* skip dependencyFlags */
+    /* skip memoryBarrierCount */
+    /* skip pMemoryBarriers */
+    /* skip bufferMemoryBarrierCount */
+    /* skip pBufferMemoryBarriers */
+    /* skip imageMemoryBarrierCount */
+    /* skip pImageMemoryBarriers */
+}
+
+static inline size_t vn_sizeof_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQuery_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&query);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBeginQuery(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQuery_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &query);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkCmdBeginQuery_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQuery_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip query */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBeginQuery_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBeginQuery_EXT);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip query */
+    /* skip flags */
+}
+
+static inline size_t vn_sizeof_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQuery_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&query);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdEndQuery(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQuery_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &query);
+}
+
+static inline size_t vn_sizeof_vkCmdEndQuery_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQuery_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip query */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdEndQuery_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdEndQuery_EXT);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip query */
+}
+
+static inline size_t vn_sizeof_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&firstQuery);
+    cmd_size += vn_sizeof_uint32_t(&queryCount);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdResetQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &firstQuery);
+    vn_encode_uint32_t(enc, &queryCount);
+}
+
+static inline size_t vn_sizeof_vkCmdResetQueryPool_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdResetQueryPool_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+}
+
+static inline size_t vn_sizeof_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkPipelineStageFlagBits(&pipelineStage);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&query);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdWriteTimestamp(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkPipelineStageFlagBits(enc, &pipelineStage);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &query);
+}
+
+static inline size_t vn_sizeof_vkCmdWriteTimestamp_reply(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip pipelineStage */
+    /* skip queryPool */
+    /* skip query */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdWriteTimestamp_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT);
+
+    /* skip commandBuffer */
+    /* skip pipelineStage */
+    /* skip queryPool */
+    /* skip query */
+}
+
+static inline size_t vn_sizeof_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&firstQuery);
+    cmd_size += vn_sizeof_uint32_t(&queryCount);
+    cmd_size += vn_sizeof_VkBuffer(&dstBuffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&dstOffset);
+    cmd_size += vn_sizeof_VkDeviceSize(&stride);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdCopyQueryPoolResults(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &firstQuery);
+    vn_encode_uint32_t(enc, &queryCount);
+    vn_encode_VkBuffer(enc, &dstBuffer);
+    vn_encode_VkDeviceSize(enc, &dstOffset);
+    vn_encode_VkDeviceSize(enc, &stride);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkCmdCopyQueryPoolResults_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+    /* skip dstBuffer */
+    /* skip dstOffset */
+    /* skip stride */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdCopyQueryPoolResults_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+    /* skip dstBuffer */
+    /* skip dstOffset */
+    /* skip stride */
+    /* skip flags */
+}
+
+static inline size_t vn_sizeof_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPushConstants_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkPipelineLayout(&layout);
+    cmd_size += vn_sizeof_VkFlags(&stageFlags);
+    cmd_size += vn_sizeof_uint32_t(&offset);
+    cmd_size += vn_sizeof_uint32_t(&size);
+    if (pValues) {
+        cmd_size += vn_sizeof_array_size(size);
+        cmd_size += vn_sizeof_blob_array(pValues, size);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdPushConstants(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPushConstants_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkPipelineLayout(enc, &layout);
+    vn_encode_VkFlags(enc, &stageFlags);
+    vn_encode_uint32_t(enc, &offset);
+    vn_encode_uint32_t(enc, &size);
+    if (pValues) {
+        vn_encode_array_size(enc, size);
+        vn_encode_blob_array(enc, pValues, size);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdPushConstants_reply(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPushConstants_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip layout */
+    /* skip stageFlags */
+    /* skip offset */
+    /* skip size */
+    /* skip pValues */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdPushConstants_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdPushConstants_EXT);
+
+    /* skip commandBuffer */
+    /* skip layout */
+    /* skip stageFlags */
+    /* skip offset */
+    /* skip size */
+    /* skip pValues */
+}
+
+static inline size_t vn_sizeof_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_simple_pointer(pRenderPassBegin);
+    if (pRenderPassBegin)
+        cmd_size += vn_sizeof_VkRenderPassBeginInfo(pRenderPassBegin);
+    cmd_size += vn_sizeof_VkSubpassContents(&contents);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBeginRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    if (vn_encode_simple_pointer(enc, pRenderPassBegin))
+        vn_encode_VkRenderPassBeginInfo(enc, pRenderPassBegin);
+    vn_encode_VkSubpassContents(enc, &contents);
+}
+
+static inline size_t vn_sizeof_vkCmdBeginRenderPass_reply(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip pRenderPassBegin */
+    /* skip contents */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBeginRenderPass_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT);
+
+    /* skip commandBuffer */
+    /* skip pRenderPassBegin */
+    /* skip contents */
+}
+
+static inline size_t vn_sizeof_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkSubpassContents(&contents);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdNextSubpass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkSubpassContents contents)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkSubpassContents(enc, &contents);
+}
+
+static inline size_t vn_sizeof_vkCmdNextSubpass_reply(VkCommandBuffer commandBuffer, VkSubpassContents contents)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip contents */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdNextSubpass_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkSubpassContents contents)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdNextSubpass_EXT);
+
+    /* skip commandBuffer */
+    /* skip contents */
+}
+
+static inline size_t vn_sizeof_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdEndRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+}
+
+static inline size_t vn_sizeof_vkCmdEndRenderPass_reply(VkCommandBuffer commandBuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdEndRenderPass_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT);
+
+    /* skip commandBuffer */
+}
+
+static inline size_t vn_sizeof_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&commandBufferCount);
+    if (pCommandBuffers) {
+        cmd_size += vn_sizeof_array_size(commandBufferCount);
+        for (uint32_t i = 0; i < commandBufferCount; i++)
+            cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdExecuteCommands(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &commandBufferCount);
+    if (pCommandBuffers) {
+        vn_encode_array_size(enc, commandBufferCount);
+        for (uint32_t i = 0; i < commandBufferCount; i++)
+            vn_encode_VkCommandBuffer(enc, &pCommandBuffers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdExecuteCommands_reply(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip commandBufferCount */
+    /* skip pCommandBuffers */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdExecuteCommands_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT);
+
+    /* skip commandBuffer */
+    /* skip commandBufferCount */
+    /* skip pCommandBuffers */
+}
+
+static inline size_t vn_sizeof_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&deviceMask);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdSetDeviceMask(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t deviceMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &deviceMask);
+}
+
+static inline size_t vn_sizeof_vkCmdSetDeviceMask_reply(VkCommandBuffer commandBuffer, uint32_t deviceMask)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip deviceMask */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdSetDeviceMask_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t deviceMask)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT);
+
+    /* skip commandBuffer */
+    /* skip deviceMask */
+}
+
+static inline size_t vn_sizeof_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchBase_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&baseGroupX);
+    cmd_size += vn_sizeof_uint32_t(&baseGroupY);
+    cmd_size += vn_sizeof_uint32_t(&baseGroupZ);
+    cmd_size += vn_sizeof_uint32_t(&groupCountX);
+    cmd_size += vn_sizeof_uint32_t(&groupCountY);
+    cmd_size += vn_sizeof_uint32_t(&groupCountZ);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdDispatchBase(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchBase_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &baseGroupX);
+    vn_encode_uint32_t(enc, &baseGroupY);
+    vn_encode_uint32_t(enc, &baseGroupZ);
+    vn_encode_uint32_t(enc, &groupCountX);
+    vn_encode_uint32_t(enc, &groupCountY);
+    vn_encode_uint32_t(enc, &groupCountZ);
+}
+
+static inline size_t vn_sizeof_vkCmdDispatchBase_reply(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchBase_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip baseGroupX */
+    /* skip baseGroupY */
+    /* skip baseGroupZ */
+    /* skip groupCountX */
+    /* skip groupCountY */
+    /* skip groupCountZ */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdDispatchBase_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdDispatchBase_EXT);
+
+    /* skip commandBuffer */
+    /* skip baseGroupX */
+    /* skip baseGroupY */
+    /* skip baseGroupZ */
+    /* skip groupCountX */
+    /* skip groupCountY */
+    /* skip groupCountZ */
+}
+
+static inline size_t vn_sizeof_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_simple_pointer(pRenderPassBegin);
+    if (pRenderPassBegin)
+        cmd_size += vn_sizeof_VkRenderPassBeginInfo(pRenderPassBegin);
+    cmd_size += vn_sizeof_simple_pointer(pSubpassBeginInfo);
+    if (pSubpassBeginInfo)
+        cmd_size += vn_sizeof_VkSubpassBeginInfo(pSubpassBeginInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBeginRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    if (vn_encode_simple_pointer(enc, pRenderPassBegin))
+        vn_encode_VkRenderPassBeginInfo(enc, pRenderPassBegin);
+    if (vn_encode_simple_pointer(enc, pSubpassBeginInfo))
+        vn_encode_VkSubpassBeginInfo(enc, pSubpassBeginInfo);
+}
+
+static inline size_t vn_sizeof_vkCmdBeginRenderPass2_reply(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip pRenderPassBegin */
+    /* skip pSubpassBeginInfo */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBeginRenderPass2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT);
+
+    /* skip commandBuffer */
+    /* skip pRenderPassBegin */
+    /* skip pSubpassBeginInfo */
+}
+
+static inline size_t vn_sizeof_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_simple_pointer(pSubpassBeginInfo);
+    if (pSubpassBeginInfo)
+        cmd_size += vn_sizeof_VkSubpassBeginInfo(pSubpassBeginInfo);
+    cmd_size += vn_sizeof_simple_pointer(pSubpassEndInfo);
+    if (pSubpassEndInfo)
+        cmd_size += vn_sizeof_VkSubpassEndInfo(pSubpassEndInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdNextSubpass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    if (vn_encode_simple_pointer(enc, pSubpassBeginInfo))
+        vn_encode_VkSubpassBeginInfo(enc, pSubpassBeginInfo);
+    if (vn_encode_simple_pointer(enc, pSubpassEndInfo))
+        vn_encode_VkSubpassEndInfo(enc, pSubpassEndInfo);
+}
+
+static inline size_t vn_sizeof_vkCmdNextSubpass2_reply(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip pSubpassBeginInfo */
+    /* skip pSubpassEndInfo */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdNextSubpass2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT);
+
+    /* skip commandBuffer */
+    /* skip pSubpassBeginInfo */
+    /* skip pSubpassEndInfo */
+}
+
+static inline size_t vn_sizeof_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_simple_pointer(pSubpassEndInfo);
+    if (pSubpassEndInfo)
+        cmd_size += vn_sizeof_VkSubpassEndInfo(pSubpassEndInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdEndRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    if (vn_encode_simple_pointer(enc, pSubpassEndInfo))
+        vn_encode_VkSubpassEndInfo(enc, pSubpassEndInfo);
+}
+
+static inline size_t vn_sizeof_vkCmdEndRenderPass2_reply(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip pSubpassEndInfo */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdEndRenderPass2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT);
+
+    /* skip commandBuffer */
+    /* skip pSubpassEndInfo */
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&buffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&offset);
+    cmd_size += vn_sizeof_VkBuffer(&countBuffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&countBufferOffset);
+    cmd_size += vn_sizeof_uint32_t(&maxDrawCount);
+    cmd_size += vn_sizeof_uint32_t(&stride);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdDrawIndirectCount(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkBuffer(enc, &buffer);
+    vn_encode_VkDeviceSize(enc, &offset);
+    vn_encode_VkBuffer(enc, &countBuffer);
+    vn_encode_VkDeviceSize(enc, &countBufferOffset);
+    vn_encode_uint32_t(enc, &maxDrawCount);
+    vn_encode_uint32_t(enc, &stride);
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndirectCount_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+    /* skip countBuffer */
+    /* skip countBufferOffset */
+    /* skip maxDrawCount */
+    /* skip stride */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdDrawIndirectCount_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+    /* skip countBuffer */
+    /* skip countBufferOffset */
+    /* skip maxDrawCount */
+    /* skip stride */
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkBuffer(&buffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&offset);
+    cmd_size += vn_sizeof_VkBuffer(&countBuffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&countBufferOffset);
+    cmd_size += vn_sizeof_uint32_t(&maxDrawCount);
+    cmd_size += vn_sizeof_uint32_t(&stride);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdDrawIndexedIndirectCount(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkBuffer(enc, &buffer);
+    vn_encode_VkDeviceSize(enc, &offset);
+    vn_encode_VkBuffer(enc, &countBuffer);
+    vn_encode_VkDeviceSize(enc, &countBufferOffset);
+    vn_encode_uint32_t(enc, &maxDrawCount);
+    vn_encode_uint32_t(enc, &stride);
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndexedIndirectCount_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+    /* skip countBuffer */
+    /* skip countBufferOffset */
+    /* skip maxDrawCount */
+    /* skip stride */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdDrawIndexedIndirectCount_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT);
+
+    /* skip commandBuffer */
+    /* skip buffer */
+    /* skip offset */
+    /* skip countBuffer */
+    /* skip countBufferOffset */
+    /* skip maxDrawCount */
+    /* skip stride */
+}
+
+static inline size_t vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&firstBinding);
+    cmd_size += vn_sizeof_uint32_t(&bindingCount);
+    if (pBuffers) {
+        cmd_size += vn_sizeof_array_size(bindingCount);
+        for (uint32_t i = 0; i < bindingCount; i++)
+            cmd_size += vn_sizeof_VkBuffer(&pBuffers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    if (pOffsets) {
+        cmd_size += vn_sizeof_array_size(bindingCount);
+        cmd_size += vn_sizeof_VkDeviceSize_array(pOffsets, bindingCount);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    if (pSizes) {
+        cmd_size += vn_sizeof_array_size(bindingCount);
+        cmd_size += vn_sizeof_VkDeviceSize_array(pSizes, bindingCount);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBindTransformFeedbackBuffersEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &firstBinding);
+    vn_encode_uint32_t(enc, &bindingCount);
+    if (pBuffers) {
+        vn_encode_array_size(enc, bindingCount);
+        for (uint32_t i = 0; i < bindingCount; i++)
+            vn_encode_VkBuffer(enc, &pBuffers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (pOffsets) {
+        vn_encode_array_size(enc, bindingCount);
+        vn_encode_VkDeviceSize_array(enc, pOffsets, bindingCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (pSizes) {
+        vn_encode_array_size(enc, bindingCount);
+        vn_encode_VkDeviceSize_array(enc, pSizes, bindingCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT_reply(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip firstBinding */
+    /* skip bindingCount */
+    /* skip pBuffers */
+    /* skip pOffsets */
+    /* skip pSizes */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBindTransformFeedbackBuffersEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT);
+
+    /* skip commandBuffer */
+    /* skip firstBinding */
+    /* skip bindingCount */
+    /* skip pBuffers */
+    /* skip pOffsets */
+    /* skip pSizes */
+}
+
+static inline size_t vn_sizeof_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&firstCounterBuffer);
+    cmd_size += vn_sizeof_uint32_t(&counterBufferCount);
+    if (pCounterBuffers) {
+        cmd_size += vn_sizeof_array_size(counterBufferCount);
+        for (uint32_t i = 0; i < counterBufferCount; i++)
+            cmd_size += vn_sizeof_VkBuffer(&pCounterBuffers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    if (pCounterBufferOffsets) {
+        cmd_size += vn_sizeof_array_size(counterBufferCount);
+        cmd_size += vn_sizeof_VkDeviceSize_array(pCounterBufferOffsets, counterBufferCount);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBeginTransformFeedbackEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &firstCounterBuffer);
+    vn_encode_uint32_t(enc, &counterBufferCount);
+    if (pCounterBuffers) {
+        vn_encode_array_size(enc, counterBufferCount);
+        for (uint32_t i = 0; i < counterBufferCount; i++)
+            vn_encode_VkBuffer(enc, &pCounterBuffers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (pCounterBufferOffsets) {
+        vn_encode_array_size(enc, counterBufferCount);
+        vn_encode_VkDeviceSize_array(enc, pCounterBufferOffsets, counterBufferCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdBeginTransformFeedbackEXT_reply(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip firstCounterBuffer */
+    /* skip counterBufferCount */
+    /* skip pCounterBuffers */
+    /* skip pCounterBufferOffsets */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBeginTransformFeedbackEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT);
+
+    /* skip commandBuffer */
+    /* skip firstCounterBuffer */
+    /* skip counterBufferCount */
+    /* skip pCounterBuffers */
+    /* skip pCounterBufferOffsets */
+}
+
+static inline size_t vn_sizeof_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&firstCounterBuffer);
+    cmd_size += vn_sizeof_uint32_t(&counterBufferCount);
+    if (pCounterBuffers) {
+        cmd_size += vn_sizeof_array_size(counterBufferCount);
+        for (uint32_t i = 0; i < counterBufferCount; i++)
+            cmd_size += vn_sizeof_VkBuffer(&pCounterBuffers[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    if (pCounterBufferOffsets) {
+        cmd_size += vn_sizeof_array_size(counterBufferCount);
+        cmd_size += vn_sizeof_VkDeviceSize_array(pCounterBufferOffsets, counterBufferCount);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdEndTransformFeedbackEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &firstCounterBuffer);
+    vn_encode_uint32_t(enc, &counterBufferCount);
+    if (pCounterBuffers) {
+        vn_encode_array_size(enc, counterBufferCount);
+        for (uint32_t i = 0; i < counterBufferCount; i++)
+            vn_encode_VkBuffer(enc, &pCounterBuffers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (pCounterBufferOffsets) {
+        vn_encode_array_size(enc, counterBufferCount);
+        vn_encode_VkDeviceSize_array(enc, pCounterBufferOffsets, counterBufferCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCmdEndTransformFeedbackEXT_reply(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip firstCounterBuffer */
+    /* skip counterBufferCount */
+    /* skip pCounterBuffers */
+    /* skip pCounterBufferOffsets */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdEndTransformFeedbackEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT);
+
+    /* skip commandBuffer */
+    /* skip firstCounterBuffer */
+    /* skip counterBufferCount */
+    /* skip pCounterBuffers */
+    /* skip pCounterBufferOffsets */
+}
+
+static inline size_t vn_sizeof_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&query);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+    cmd_size += vn_sizeof_uint32_t(&index);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdBeginQueryIndexedEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &query);
+    vn_encode_VkFlags(enc, &flags);
+    vn_encode_uint32_t(enc, &index);
+}
+
+static inline size_t vn_sizeof_vkCmdBeginQueryIndexedEXT_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip query */
+    /* skip flags */
+    /* skip index */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdBeginQueryIndexedEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip query */
+    /* skip flags */
+    /* skip index */
+}
+
+static inline size_t vn_sizeof_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&query);
+    cmd_size += vn_sizeof_uint32_t(&index);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdEndQueryIndexedEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &query);
+    vn_encode_uint32_t(enc, &index);
+}
+
+static inline size_t vn_sizeof_vkCmdEndQueryIndexedEXT_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip query */
+    /* skip index */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdEndQueryIndexedEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT);
+
+    /* skip commandBuffer */
+    /* skip queryPool */
+    /* skip query */
+    /* skip index */
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
+    cmd_size += vn_sizeof_uint32_t(&instanceCount);
+    cmd_size += vn_sizeof_uint32_t(&firstInstance);
+    cmd_size += vn_sizeof_VkBuffer(&counterBuffer);
+    cmd_size += vn_sizeof_VkDeviceSize(&counterBufferOffset);
+    cmd_size += vn_sizeof_uint32_t(&counterOffset);
+    cmd_size += vn_sizeof_uint32_t(&vertexStride);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCmdDrawIndirectByteCountEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkCommandBuffer(enc, &commandBuffer);
+    vn_encode_uint32_t(enc, &instanceCount);
+    vn_encode_uint32_t(enc, &firstInstance);
+    vn_encode_VkBuffer(enc, &counterBuffer);
+    vn_encode_VkDeviceSize(enc, &counterBufferOffset);
+    vn_encode_uint32_t(enc, &counterOffset);
+    vn_encode_uint32_t(enc, &vertexStride);
+}
+
+static inline size_t vn_sizeof_vkCmdDrawIndirectByteCountEXT_reply(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip commandBuffer */
+    /* skip instanceCount */
+    /* skip firstInstance */
+    /* skip counterBuffer */
+    /* skip counterBufferOffset */
+    /* skip counterOffset */
+    /* skip vertexStride */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCmdDrawIndirectByteCountEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT);
+
+    /* skip commandBuffer */
+    /* skip instanceCount */
+    /* skip firstInstance */
+    /* skip counterBuffer */
+    /* skip counterBufferOffset */
+    /* skip counterOffset */
+    /* skip vertexStride */
+}
+
+static inline void vn_submit_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkAllocateCommandBuffers(&submit->command, cmd_flags, device, pAllocateInfo, pCommandBuffers);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateCommandBuffers_reply(device, pAllocateInfo, pCommandBuffers) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkFreeCommandBuffers(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkFreeCommandBuffers(&submit->command, cmd_flags, device, commandPool, commandBufferCount, pCommandBuffers);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeCommandBuffers_reply(device, commandPool, commandBufferCount, pCommandBuffers) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkBeginCommandBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkBeginCommandBuffer(commandBuffer, pBeginInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkBeginCommandBuffer(&submit->command, cmd_flags, commandBuffer, pBeginInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBeginCommandBuffer_reply(commandBuffer, pBeginInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkEndCommandBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEndCommandBuffer(commandBuffer);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEndCommandBuffer(&submit->command, cmd_flags, commandBuffer);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEndCommandBuffer_reply(commandBuffer) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetCommandBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetCommandBuffer(commandBuffer, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetCommandBuffer(&submit->command, cmd_flags, commandBuffer, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetCommandBuffer_reply(commandBuffer, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBindPipeline(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBindPipeline(&submit->command, cmd_flags, commandBuffer, pipelineBindPoint, pipeline);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindPipeline_reply(commandBuffer, pipelineBindPoint, pipeline) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetViewport(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetViewport(&submit->command, cmd_flags, commandBuffer, firstViewport, viewportCount, pViewports);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetViewport_reply(commandBuffer, firstViewport, viewportCount, pViewports) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetScissor(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetScissor(&submit->command, cmd_flags, commandBuffer, firstScissor, scissorCount, pScissors);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetScissor_reply(commandBuffer, firstScissor, scissorCount, pScissors) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetLineWidth(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float lineWidth, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetLineWidth(commandBuffer, lineWidth);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetLineWidth(&submit->command, cmd_flags, commandBuffer, lineWidth);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetLineWidth_reply(commandBuffer, lineWidth) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetDepthBias(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetDepthBias(&submit->command, cmd_flags, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthBias_reply(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetBlendConstants(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const float blendConstants[4], struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetBlendConstants(commandBuffer, blendConstants);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetBlendConstants(&submit->command, cmd_flags, commandBuffer, blendConstants);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetBlendConstants_reply(commandBuffer, blendConstants) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetDepthBounds(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetDepthBounds(&submit->command, cmd_flags, commandBuffer, minDepthBounds, maxDepthBounds);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthBounds_reply(commandBuffer, minDepthBounds, maxDepthBounds) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetStencilCompareMask(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetStencilCompareMask(&submit->command, cmd_flags, commandBuffer, faceMask, compareMask);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilCompareMask_reply(commandBuffer, faceMask, compareMask) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetStencilWriteMask(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetStencilWriteMask(&submit->command, cmd_flags, commandBuffer, faceMask, writeMask);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilWriteMask_reply(commandBuffer, faceMask, writeMask) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetStencilReference(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetStencilReference(commandBuffer, faceMask, reference);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetStencilReference(&submit->command, cmd_flags, commandBuffer, faceMask, reference);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilReference_reply(commandBuffer, faceMask, reference) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBindDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBindDescriptorSets(&submit->command, cmd_flags, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindDescriptorSets_reply(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBindIndexBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBindIndexBuffer(&submit->command, cmd_flags, commandBuffer, buffer, offset, indexType);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindIndexBuffer_reply(commandBuffer, buffer, offset, indexType) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBindVertexBuffers(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBindVertexBuffers(&submit->command, cmd_flags, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindVertexBuffers_reply(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdDraw(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdDraw(&submit->command, cmd_flags, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDraw_reply(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdDrawIndexed(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdDrawIndexed(&submit->command, cmd_flags, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndexed_reply(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdDrawIndirect(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdDrawIndirect(&submit->command, cmd_flags, commandBuffer, buffer, offset, drawCount, stride);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndirect_reply(commandBuffer, buffer, offset, drawCount, stride) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdDrawIndexedIndirect(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdDrawIndexedIndirect(&submit->command, cmd_flags, commandBuffer, buffer, offset, drawCount, stride);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndexedIndirect_reply(commandBuffer, buffer, offset, drawCount, stride) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdDispatch(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdDispatch(&submit->command, cmd_flags, commandBuffer, groupCountX, groupCountY, groupCountZ);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDispatch_reply(commandBuffer, groupCountX, groupCountY, groupCountZ) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdDispatchIndirect(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdDispatchIndirect(commandBuffer, buffer, offset);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdDispatchIndirect(&submit->command, cmd_flags, commandBuffer, buffer, offset);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDispatchIndirect_reply(commandBuffer, buffer, offset) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdCopyBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdCopyBuffer(&submit->command, cmd_flags, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyBuffer_reply(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdCopyImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdCopyImage(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyImage_reply(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBlitImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBlitImage(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBlitImage_reply(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdCopyBufferToImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdCopyBufferToImage(&submit->command, cmd_flags, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyBufferToImage_reply(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdCopyImageToBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdCopyImageToBuffer(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyImageToBuffer_reply(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdUpdateBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdUpdateBuffer(&submit->command, cmd_flags, commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdUpdateBuffer_reply(commandBuffer, dstBuffer, dstOffset, dataSize, pData) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdFillBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdFillBuffer(&submit->command, cmd_flags, commandBuffer, dstBuffer, dstOffset, size, data);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdFillBuffer_reply(commandBuffer, dstBuffer, dstOffset, size, data) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdClearColorImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdClearColorImage(&submit->command, cmd_flags, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdClearColorImage_reply(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdClearDepthStencilImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdClearDepthStencilImage(&submit->command, cmd_flags, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdClearDepthStencilImage_reply(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdClearAttachments(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdClearAttachments(&submit->command, cmd_flags, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdClearAttachments_reply(commandBuffer, attachmentCount, pAttachments, rectCount, pRects) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdResolveImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdResolveImage(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResolveImage_reply(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetEvent(commandBuffer, event, stageMask);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetEvent(&submit->command, cmd_flags, commandBuffer, event, stageMask);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetEvent_reply(commandBuffer, event, stageMask) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdResetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdResetEvent(commandBuffer, event, stageMask);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdResetEvent(&submit->command, cmd_flags, commandBuffer, event, stageMask);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResetEvent_reply(commandBuffer, event, stageMask) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdWaitEvents(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdWaitEvents(&submit->command, cmd_flags, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdWaitEvents_reply(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdPipelineBarrier(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdPipelineBarrier(&submit->command, cmd_flags, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdPipelineBarrier_reply(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBeginQuery(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBeginQuery(&submit->command, cmd_flags, commandBuffer, queryPool, query, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginQuery_reply(commandBuffer, queryPool, query, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdEndQuery(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdEndQuery(commandBuffer, queryPool, query);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdEndQuery(&submit->command, cmd_flags, commandBuffer, queryPool, query);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndQuery_reply(commandBuffer, queryPool, query) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdResetQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdResetQueryPool(&submit->command, cmd_flags, commandBuffer, queryPool, firstQuery, queryCount);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResetQueryPool_reply(commandBuffer, queryPool, firstQuery, queryCount) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdWriteTimestamp(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdWriteTimestamp(&submit->command, cmd_flags, commandBuffer, pipelineStage, queryPool, query);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdWriteTimestamp_reply(commandBuffer, pipelineStage, queryPool, query) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdCopyQueryPoolResults(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdCopyQueryPoolResults(&submit->command, cmd_flags, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyQueryPoolResults_reply(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdPushConstants(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdPushConstants(&submit->command, cmd_flags, commandBuffer, layout, stageFlags, offset, size, pValues);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdPushConstants_reply(commandBuffer, layout, stageFlags, offset, size, pValues) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBeginRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBeginRenderPass(&submit->command, cmd_flags, commandBuffer, pRenderPassBegin, contents);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginRenderPass_reply(commandBuffer, pRenderPassBegin, contents) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdNextSubpass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkSubpassContents contents, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdNextSubpass(commandBuffer, contents);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdNextSubpass(&submit->command, cmd_flags, commandBuffer, contents);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdNextSubpass_reply(commandBuffer, contents) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdEndRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdEndRenderPass(commandBuffer);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdEndRenderPass(&submit->command, cmd_flags, commandBuffer);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndRenderPass_reply(commandBuffer) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdExecuteCommands(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdExecuteCommands(&submit->command, cmd_flags, commandBuffer, commandBufferCount, pCommandBuffers);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdExecuteCommands_reply(commandBuffer, commandBufferCount, pCommandBuffers) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdSetDeviceMask(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t deviceMask, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdSetDeviceMask(commandBuffer, deviceMask);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdSetDeviceMask(&submit->command, cmd_flags, commandBuffer, deviceMask);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDeviceMask_reply(commandBuffer, deviceMask) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdDispatchBase(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdDispatchBase(&submit->command, cmd_flags, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDispatchBase_reply(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBeginRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBeginRenderPass2(&submit->command, cmd_flags, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginRenderPass2_reply(commandBuffer, pRenderPassBegin, pSubpassBeginInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdNextSubpass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdNextSubpass2(&submit->command, cmd_flags, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdNextSubpass2_reply(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdEndRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdEndRenderPass2(&submit->command, cmd_flags, commandBuffer, pSubpassEndInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndRenderPass2_reply(commandBuffer, pSubpassEndInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdDrawIndirectCount(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdDrawIndirectCount(&submit->command, cmd_flags, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndirectCount_reply(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdDrawIndexedIndirectCount(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdDrawIndexedIndirectCount(&submit->command, cmd_flags, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndexedIndirectCount_reply(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBindTransformFeedbackBuffersEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBindTransformFeedbackBuffersEXT(&submit->command, cmd_flags, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT_reply(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBeginTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBeginTransformFeedbackEXT(&submit->command, cmd_flags, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginTransformFeedbackEXT_reply(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdEndTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdEndTransformFeedbackEXT(&submit->command, cmd_flags, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndTransformFeedbackEXT_reply(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdBeginQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdBeginQueryIndexedEXT(&submit->command, cmd_flags, commandBuffer, queryPool, query, flags, index);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginQueryIndexedEXT_reply(commandBuffer, queryPool, query, flags, index) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdEndQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdEndQueryIndexedEXT(&submit->command, cmd_flags, commandBuffer, queryPool, query, index);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndQueryIndexedEXT_reply(commandBuffer, queryPool, query, index) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCmdDrawIndirectByteCountEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCmdDrawIndirectByteCountEXT(&submit->command, cmd_flags, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndirectByteCountEXT_reply(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkAllocateCommandBuffers(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pCommandBuffers, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkAllocateCommandBuffers_reply(&submit.reply, device, pAllocateInfo, pCommandBuffers);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkAllocateCommandBuffers(vn_instance, 0, device, pAllocateInfo, pCommandBuffers, &submit);
+}
+
+static inline void vn_call_vkFreeCommandBuffers(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkFreeCommandBuffers(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, commandBufferCount, pCommandBuffers, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkFreeCommandBuffers_reply(&submit.reply, device, commandPool, commandBufferCount, pCommandBuffers);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkFreeCommandBuffers(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkFreeCommandBuffers(vn_instance, 0, device, commandPool, commandBufferCount, pCommandBuffers, &submit);
+}
+
+static inline VkResult vn_call_vkBeginCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkBeginCommandBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pBeginInfo, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkBeginCommandBuffer_reply(&submit.reply, commandBuffer, pBeginInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkBeginCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkBeginCommandBuffer(vn_instance, 0, commandBuffer, pBeginInfo, &submit);
+}
+
+static inline VkResult vn_call_vkEndCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEndCommandBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEndCommandBuffer_reply(&submit.reply, commandBuffer);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEndCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEndCommandBuffer(vn_instance, 0, commandBuffer, &submit);
+}
+
+static inline VkResult vn_call_vkResetCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetCommandBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, flags, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkResetCommandBuffer_reply(&submit.reply, commandBuffer, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkResetCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetCommandBuffer(vn_instance, 0, commandBuffer, flags, &submit);
+}
+
+static inline void vn_call_vkCmdBindPipeline(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBindPipeline(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pipelineBindPoint, pipeline, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBindPipeline_reply(&submit.reply, commandBuffer, pipelineBindPoint, pipeline);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBindPipeline(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBindPipeline(vn_instance, 0, commandBuffer, pipelineBindPoint, pipeline, &submit);
+}
+
+static inline void vn_call_vkCmdSetViewport(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetViewport(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstViewport, viewportCount, pViewports, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetViewport_reply(&submit.reply, commandBuffer, firstViewport, viewportCount, pViewports);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetViewport(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetViewport(vn_instance, 0, commandBuffer, firstViewport, viewportCount, pViewports, &submit);
+}
+
+static inline void vn_call_vkCmdSetScissor(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetScissor(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstScissor, scissorCount, pScissors, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetScissor_reply(&submit.reply, commandBuffer, firstScissor, scissorCount, pScissors);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetScissor(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetScissor(vn_instance, 0, commandBuffer, firstScissor, scissorCount, pScissors, &submit);
+}
+
+static inline void vn_call_vkCmdSetLineWidth(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float lineWidth)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetLineWidth(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, lineWidth, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetLineWidth_reply(&submit.reply, commandBuffer, lineWidth);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetLineWidth(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float lineWidth)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetLineWidth(vn_instance, 0, commandBuffer, lineWidth, &submit);
+}
+
+static inline void vn_call_vkCmdSetDepthBias(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetDepthBias(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetDepthBias_reply(&submit.reply, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetDepthBias(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetDepthBias(vn_instance, 0, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor, &submit);
+}
+
+static inline void vn_call_vkCmdSetBlendConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const float blendConstants[4])
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetBlendConstants(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, blendConstants, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetBlendConstants_reply(&submit.reply, commandBuffer, blendConstants);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetBlendConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const float blendConstants[4])
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetBlendConstants(vn_instance, 0, commandBuffer, blendConstants, &submit);
+}
+
+static inline void vn_call_vkCmdSetDepthBounds(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetDepthBounds(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, minDepthBounds, maxDepthBounds, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetDepthBounds_reply(&submit.reply, commandBuffer, minDepthBounds, maxDepthBounds);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetDepthBounds(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetDepthBounds(vn_instance, 0, commandBuffer, minDepthBounds, maxDepthBounds, &submit);
+}
+
+static inline void vn_call_vkCmdSetStencilCompareMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetStencilCompareMask(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, faceMask, compareMask, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetStencilCompareMask_reply(&submit.reply, commandBuffer, faceMask, compareMask);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetStencilCompareMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetStencilCompareMask(vn_instance, 0, commandBuffer, faceMask, compareMask, &submit);
+}
+
+static inline void vn_call_vkCmdSetStencilWriteMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetStencilWriteMask(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, faceMask, writeMask, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetStencilWriteMask_reply(&submit.reply, commandBuffer, faceMask, writeMask);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetStencilWriteMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetStencilWriteMask(vn_instance, 0, commandBuffer, faceMask, writeMask, &submit);
+}
+
+static inline void vn_call_vkCmdSetStencilReference(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetStencilReference(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, faceMask, reference, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetStencilReference_reply(&submit.reply, commandBuffer, faceMask, reference);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetStencilReference(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetStencilReference(vn_instance, 0, commandBuffer, faceMask, reference, &submit);
+}
+
+static inline void vn_call_vkCmdBindDescriptorSets(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBindDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBindDescriptorSets_reply(&submit.reply, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBindDescriptorSets(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBindDescriptorSets(vn_instance, 0, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets, &submit);
+}
+
+static inline void vn_call_vkCmdBindIndexBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBindIndexBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, indexType, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBindIndexBuffer_reply(&submit.reply, commandBuffer, buffer, offset, indexType);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBindIndexBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBindIndexBuffer(vn_instance, 0, commandBuffer, buffer, offset, indexType, &submit);
+}
+
+static inline void vn_call_vkCmdBindVertexBuffers(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBindVertexBuffers(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBindVertexBuffers_reply(&submit.reply, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBindVertexBuffers(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBindVertexBuffers(vn_instance, 0, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, &submit);
+}
+
+static inline void vn_call_vkCmdDraw(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDraw(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdDraw_reply(&submit.reply, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdDraw(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDraw(vn_instance, 0, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance, &submit);
+}
+
+static inline void vn_call_vkCmdDrawIndexed(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndexed(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdDrawIndexed_reply(&submit.reply, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdDrawIndexed(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndexed(vn_instance, 0, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance, &submit);
+}
+
+static inline void vn_call_vkCmdDrawIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndirect(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, drawCount, stride, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdDrawIndirect_reply(&submit.reply, commandBuffer, buffer, offset, drawCount, stride);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdDrawIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndirect(vn_instance, 0, commandBuffer, buffer, offset, drawCount, stride, &submit);
+}
+
+static inline void vn_call_vkCmdDrawIndexedIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndexedIndirect(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, drawCount, stride, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdDrawIndexedIndirect_reply(&submit.reply, commandBuffer, buffer, offset, drawCount, stride);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdDrawIndexedIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndexedIndirect(vn_instance, 0, commandBuffer, buffer, offset, drawCount, stride, &submit);
+}
+
+static inline void vn_call_vkCmdDispatch(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDispatch(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, groupCountX, groupCountY, groupCountZ, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdDispatch_reply(&submit.reply, commandBuffer, groupCountX, groupCountY, groupCountZ);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdDispatch(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDispatch(vn_instance, 0, commandBuffer, groupCountX, groupCountY, groupCountZ, &submit);
+}
+
+static inline void vn_call_vkCmdDispatchIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDispatchIndirect(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdDispatchIndirect_reply(&submit.reply, commandBuffer, buffer, offset);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdDispatchIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDispatchIndirect(vn_instance, 0, commandBuffer, buffer, offset, &submit);
+}
+
+static inline void vn_call_vkCmdCopyBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdCopyBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdCopyBuffer_reply(&submit.reply, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdCopyBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdCopyBuffer(vn_instance, 0, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions, &submit);
+}
+
+static inline void vn_call_vkCmdCopyImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdCopyImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdCopyImage_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdCopyImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdCopyImage(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit);
+}
+
+static inline void vn_call_vkCmdBlitImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBlitImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBlitImage_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBlitImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBlitImage(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter, &submit);
+}
+
+static inline void vn_call_vkCmdCopyBufferToImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdCopyBufferToImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdCopyBufferToImage_reply(&submit.reply, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdCopyBufferToImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdCopyBufferToImage(vn_instance, 0, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions, &submit);
+}
+
+static inline void vn_call_vkCmdCopyImageToBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdCopyImageToBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdCopyImageToBuffer_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdCopyImageToBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdCopyImageToBuffer(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions, &submit);
+}
+
+static inline void vn_call_vkCmdUpdateBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdUpdateBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, dstBuffer, dstOffset, dataSize, pData, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdUpdateBuffer_reply(&submit.reply, commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdUpdateBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdUpdateBuffer(vn_instance, 0, commandBuffer, dstBuffer, dstOffset, dataSize, pData, &submit);
+}
+
+static inline void vn_call_vkCmdFillBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdFillBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, dstBuffer, dstOffset, size, data, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdFillBuffer_reply(&submit.reply, commandBuffer, dstBuffer, dstOffset, size, data);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdFillBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdFillBuffer(vn_instance, 0, commandBuffer, dstBuffer, dstOffset, size, data, &submit);
+}
+
+static inline void vn_call_vkCmdClearColorImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdClearColorImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdClearColorImage_reply(&submit.reply, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdClearColorImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdClearColorImage(vn_instance, 0, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges, &submit);
+}
+
+static inline void vn_call_vkCmdClearDepthStencilImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdClearDepthStencilImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdClearDepthStencilImage_reply(&submit.reply, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdClearDepthStencilImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdClearDepthStencilImage(vn_instance, 0, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges, &submit);
+}
+
+static inline void vn_call_vkCmdClearAttachments(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdClearAttachments(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, attachmentCount, pAttachments, rectCount, pRects, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdClearAttachments_reply(&submit.reply, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdClearAttachments(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdClearAttachments(vn_instance, 0, commandBuffer, attachmentCount, pAttachments, rectCount, pRects, &submit);
+}
+
+static inline void vn_call_vkCmdResolveImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdResolveImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdResolveImage_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdResolveImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdResolveImage(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit);
+}
+
+static inline void vn_call_vkCmdSetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, event, stageMask, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetEvent_reply(&submit.reply, commandBuffer, event, stageMask);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetEvent(vn_instance, 0, commandBuffer, event, stageMask, &submit);
+}
+
+static inline void vn_call_vkCmdResetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdResetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, event, stageMask, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdResetEvent_reply(&submit.reply, commandBuffer, event, stageMask);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdResetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdResetEvent(vn_instance, 0, commandBuffer, event, stageMask, &submit);
+}
+
+static inline void vn_call_vkCmdWaitEvents(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdWaitEvents(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdWaitEvents_reply(&submit.reply, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdWaitEvents(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdWaitEvents(vn_instance, 0, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit);
+}
+
+static inline void vn_call_vkCmdPipelineBarrier(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdPipelineBarrier(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdPipelineBarrier_reply(&submit.reply, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdPipelineBarrier(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdPipelineBarrier(vn_instance, 0, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit);
+}
+
+static inline void vn_call_vkCmdBeginQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBeginQuery(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, flags, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBeginQuery_reply(&submit.reply, commandBuffer, queryPool, query, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBeginQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBeginQuery(vn_instance, 0, commandBuffer, queryPool, query, flags, &submit);
+}
+
+static inline void vn_call_vkCmdEndQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdEndQuery(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdEndQuery_reply(&submit.reply, commandBuffer, queryPool, query);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdEndQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdEndQuery(vn_instance, 0, commandBuffer, queryPool, query, &submit);
+}
+
+static inline void vn_call_vkCmdResetQueryPool(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdResetQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, firstQuery, queryCount, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdResetQueryPool_reply(&submit.reply, commandBuffer, queryPool, firstQuery, queryCount);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdResetQueryPool(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdResetQueryPool(vn_instance, 0, commandBuffer, queryPool, firstQuery, queryCount, &submit);
+}
+
+static inline void vn_call_vkCmdWriteTimestamp(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdWriteTimestamp(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pipelineStage, queryPool, query, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdWriteTimestamp_reply(&submit.reply, commandBuffer, pipelineStage, queryPool, query);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdWriteTimestamp(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdWriteTimestamp(vn_instance, 0, commandBuffer, pipelineStage, queryPool, query, &submit);
+}
+
+static inline void vn_call_vkCmdCopyQueryPoolResults(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdCopyQueryPoolResults(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdCopyQueryPoolResults_reply(&submit.reply, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdCopyQueryPoolResults(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdCopyQueryPoolResults(vn_instance, 0, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags, &submit);
+}
+
+static inline void vn_call_vkCmdPushConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdPushConstants(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, layout, stageFlags, offset, size, pValues, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdPushConstants_reply(&submit.reply, commandBuffer, layout, stageFlags, offset, size, pValues);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdPushConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdPushConstants(vn_instance, 0, commandBuffer, layout, stageFlags, offset, size, pValues, &submit);
+}
+
+static inline void vn_call_vkCmdBeginRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBeginRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pRenderPassBegin, contents, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBeginRenderPass_reply(&submit.reply, commandBuffer, pRenderPassBegin, contents);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBeginRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBeginRenderPass(vn_instance, 0, commandBuffer, pRenderPassBegin, contents, &submit);
+}
+
+static inline void vn_call_vkCmdNextSubpass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkSubpassContents contents)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdNextSubpass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, contents, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdNextSubpass_reply(&submit.reply, commandBuffer, contents);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdNextSubpass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkSubpassContents contents)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdNextSubpass(vn_instance, 0, commandBuffer, contents, &submit);
+}
+
+static inline void vn_call_vkCmdEndRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdEndRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdEndRenderPass_reply(&submit.reply, commandBuffer);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdEndRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdEndRenderPass(vn_instance, 0, commandBuffer, &submit);
+}
+
+static inline void vn_call_vkCmdExecuteCommands(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdExecuteCommands(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, commandBufferCount, pCommandBuffers, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdExecuteCommands_reply(&submit.reply, commandBuffer, commandBufferCount, pCommandBuffers);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdExecuteCommands(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdExecuteCommands(vn_instance, 0, commandBuffer, commandBufferCount, pCommandBuffers, &submit);
+}
+
+static inline void vn_call_vkCmdSetDeviceMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t deviceMask)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetDeviceMask(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, deviceMask, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdSetDeviceMask_reply(&submit.reply, commandBuffer, deviceMask);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdSetDeviceMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t deviceMask)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdSetDeviceMask(vn_instance, 0, commandBuffer, deviceMask, &submit);
+}
+
+static inline void vn_call_vkCmdDispatchBase(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDispatchBase(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdDispatchBase_reply(&submit.reply, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdDispatchBase(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDispatchBase(vn_instance, 0, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, &submit);
+}
+
+static inline void vn_call_vkCmdBeginRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBeginRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pRenderPassBegin, pSubpassBeginInfo, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBeginRenderPass2_reply(&submit.reply, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBeginRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBeginRenderPass2(vn_instance, 0, commandBuffer, pRenderPassBegin, pSubpassBeginInfo, &submit);
+}
+
+static inline void vn_call_vkCmdNextSubpass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdNextSubpass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdNextSubpass2_reply(&submit.reply, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdNextSubpass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdNextSubpass2(vn_instance, 0, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, &submit);
+}
+
+static inline void vn_call_vkCmdEndRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdEndRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pSubpassEndInfo, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdEndRenderPass2_reply(&submit.reply, commandBuffer, pSubpassEndInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdEndRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdEndRenderPass2(vn_instance, 0, commandBuffer, pSubpassEndInfo, &submit);
+}
+
+static inline void vn_call_vkCmdDrawIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndirectCount(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdDrawIndirectCount_reply(&submit.reply, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdDrawIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndirectCount(vn_instance, 0, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit);
+}
+
+static inline void vn_call_vkCmdDrawIndexedIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndexedIndirectCount(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdDrawIndexedIndirectCount_reply(&submit.reply, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdDrawIndexedIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndexedIndirectCount(vn_instance, 0, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit);
+}
+
+static inline void vn_call_vkCmdBindTransformFeedbackBuffersEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBindTransformFeedbackBuffersEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBindTransformFeedbackBuffersEXT_reply(&submit.reply, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBindTransformFeedbackBuffersEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBindTransformFeedbackBuffersEXT(vn_instance, 0, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, &submit);
+}
+
+static inline void vn_call_vkCmdBeginTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBeginTransformFeedbackEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBeginTransformFeedbackEXT_reply(&submit.reply, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBeginTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBeginTransformFeedbackEXT(vn_instance, 0, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit);
+}
+
+static inline void vn_call_vkCmdEndTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdEndTransformFeedbackEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdEndTransformFeedbackEXT_reply(&submit.reply, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdEndTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdEndTransformFeedbackEXT(vn_instance, 0, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit);
+}
+
+static inline void vn_call_vkCmdBeginQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBeginQueryIndexedEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, flags, index, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdBeginQueryIndexedEXT_reply(&submit.reply, commandBuffer, queryPool, query, flags, index);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdBeginQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdBeginQueryIndexedEXT(vn_instance, 0, commandBuffer, queryPool, query, flags, index, &submit);
+}
+
+static inline void vn_call_vkCmdEndQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdEndQueryIndexedEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, index, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdEndQueryIndexedEXT_reply(&submit.reply, commandBuffer, queryPool, query, index);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdEndQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdEndQueryIndexedEXT(vn_instance, 0, commandBuffer, queryPool, query, index, &submit);
+}
+
+static inline void vn_call_vkCmdDrawIndirectByteCountEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndirectByteCountEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCmdDrawIndirectByteCountEXT_reply(&submit.reply, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCmdDrawIndirectByteCountEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCmdDrawIndirectByteCountEXT(vn_instance, 0, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_COMMAND_BUFFER_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_command_pool.h b/src/virtio/venus-protocol/vn_protocol_driver_command_pool.h
new file mode 100644 (file)
index 0000000..e3f332a
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_command_pool.h
@@ -0,0 +1,449 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_COMMAND_POOL_H
+#define VN_PROTOCOL_DRIVER_COMMAND_POOL_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkCommandPoolCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkCommandPoolCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkCommandPoolCreateInfo_self(const VkCommandPoolCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkCommandPoolCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkCommandPoolCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkCommandPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkCommandPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkCommandPoolCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->queueFamilyIndex);
+}
+
+static inline void
+vn_encode_VkCommandPoolCreateInfo(struct vn_cs_encoder *enc, const VkCommandPoolCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO });
+    vn_encode_VkCommandPoolCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkCommandPoolCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkCommandPoolCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pCommandPool);
+    if (pCommandPool)
+        cmd_size += vn_sizeof_VkCommandPool(pCommandPool);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkCommandPoolCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pCommandPool))
+        vn_encode_VkCommandPool(enc, pCommandPool);
+}
+
+static inline size_t vn_sizeof_vkCreateCommandPool_reply(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pCommandPool);
+    if (pCommandPool)
+        cmd_size += vn_sizeof_VkCommandPool(pCommandPool);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateCommandPool_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkCommandPool(dec, pCommandPool);
+    } else {
+        pCommandPool = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkCommandPool(enc, &commandPool);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyCommandPool_reply(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip commandPool */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyCommandPool_EXT);
+
+    /* skip device */
+    /* skip commandPool */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkCommandPool(enc, &commandPool);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkResetCommandPool_reply(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip commandPool */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkResetCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetCommandPool_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip commandPool */
+    /* skip flags */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkTrimCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkCommandPool(enc, &commandPool);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkTrimCommandPool_reply(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip commandPool */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkTrimCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkTrimCommandPool_EXT);
+
+    /* skip device */
+    /* skip commandPool */
+    /* skip flags */
+}
+
+static inline void vn_submit_vkCreateCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateCommandPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pCommandPool);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateCommandPool_reply(device, pCreateInfo, pAllocator, pCommandPool) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyCommandPool(device, commandPool, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyCommandPool(&submit->command, cmd_flags, device, commandPool, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyCommandPool_reply(device, commandPool, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetCommandPool(device, commandPool, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetCommandPool(&submit->command, cmd_flags, device, commandPool, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetCommandPool_reply(device, commandPool, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkTrimCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkTrimCommandPool(device, commandPool, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkTrimCommandPool(&submit->command, cmd_flags, device, commandPool, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkTrimCommandPool_reply(device, commandPool, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pCommandPool, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateCommandPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pCommandPool);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateCommandPool(vn_instance, 0, device, pCreateInfo, pAllocator, pCommandPool, &submit);
+}
+
+static inline void vn_call_vkDestroyCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyCommandPool_reply(&submit.reply, device, commandPool, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyCommandPool(vn_instance, 0, device, commandPool, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkResetCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkResetCommandPool_reply(&submit.reply, device, commandPool, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkResetCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetCommandPool(vn_instance, 0, device, commandPool, flags, &submit);
+}
+
+static inline void vn_call_vkTrimCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkTrimCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkTrimCommandPool_reply(&submit.reply, device, commandPool, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkTrimCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkTrimCommandPool(vn_instance, 0, device, commandPool, flags, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_COMMAND_POOL_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_commands.h b/src/virtio/venus-protocol/vn_protocol_driver_commands.h
deleted file mode 100644 (file)
index ff3d7d0..0000000
--- a/src/virtio/venus-protocol/vn_protocol_driver_commands.h
+++ /dev/null
@@ -1,11871 +0,0 @@
-/* This file is generated by venus-protocol git-72189394. */
-
-/*
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef VN_PROTOCOL_DRIVER_COMMANDS_H
-#define VN_PROTOCOL_DRIVER_COMMANDS_H
-
-#include "vn_protocol_driver_structs.h"
-
-/*
- * These commands are not included
- *
- *   vkGetDeviceProcAddr
- *   vkGetInstanceProcAddr
- *   vkMapMemory
- *   vkUpdateDescriptorSetWithTemplate
- */
-
-static inline size_t vn_sizeof_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkInstanceCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pInstance);
-    if (pInstance)
-        cmd_size += vn_sizeof_VkInstance(pInstance);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateInstance(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkInstanceCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pInstance))
-        vn_encode_VkInstance(enc, pInstance);
-}
-
-static inline size_t vn_sizeof_vkCreateInstance_reply(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pInstance);
-    if (pInstance)
-        cmd_size += vn_sizeof_VkInstance(pInstance);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateInstance_reply(struct vn_cs_decoder *dec, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateInstance_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkInstance(dec, pInstance);
-    } else {
-        pInstance = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkInstance(&instance);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyInstance(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkInstance(enc, &instance);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyInstance_reply(VkInstance instance, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip instance */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyInstance_reply(struct vn_cs_decoder *dec, VkInstance instance, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyInstance_EXT);
-
-    /* skip instance */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkInstance(&instance);
-    cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
-    if (pPhysicalDeviceCount)
-        cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
-    if (pPhysicalDevices) {
-        cmd_size += vn_sizeof_array_size(*pPhysicalDeviceCount);
-        for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++)
-            cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkInstance(enc, &instance);
-    if (vn_encode_simple_pointer(enc, pPhysicalDeviceCount))
-        vn_encode_uint32_t(enc, pPhysicalDeviceCount);
-    if (pPhysicalDevices) {
-        vn_encode_array_size(enc, *pPhysicalDeviceCount);
-        for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++)
-            vn_encode_VkPhysicalDevice(enc, &pPhysicalDevices[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip instance */
-    cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
-    if (pPhysicalDeviceCount)
-        cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
-    if (pPhysicalDevices) {
-        cmd_size += vn_sizeof_array_size(*pPhysicalDeviceCount);
-        for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++)
-            cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip instance */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pPhysicalDeviceCount);
-    } else {
-        pPhysicalDeviceCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pPhysicalDeviceCount);
-        for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++)
-            vn_decode_VkPhysicalDevice(dec, &pPhysicalDevices[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pPhysicalDevices = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pProperties);
-    if (pProperties)
-        cmd_size += vn_sizeof_VkPhysicalDeviceProperties_partial(pProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pProperties))
-        vn_encode_VkPhysicalDeviceProperties_partial(enc, pProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    cmd_size += vn_sizeof_simple_pointer(pProperties);
-    if (pProperties)
-        cmd_size += vn_sizeof_VkPhysicalDeviceProperties(pProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT);
-
-    /* skip physicalDevice */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkPhysicalDeviceProperties(dec, pProperties);
-    } else {
-        pProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
-    if (pQueueFamilyPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
-    if (pQueueFamilyProperties) {
-        cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount);
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
-            cmd_size += vn_sizeof_VkQueueFamilyProperties_partial(&pQueueFamilyProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
-        vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
-    if (pQueueFamilyProperties) {
-        vn_encode_array_size(enc, *pQueueFamilyPropertyCount);
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
-            vn_encode_VkQueueFamilyProperties_partial(enc, &pQueueFamilyProperties[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
-    if (pQueueFamilyPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
-    if (pQueueFamilyProperties) {
-        cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount);
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
-            cmd_size += vn_sizeof_VkQueueFamilyProperties(&pQueueFamilyProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT);
-
-    /* skip physicalDevice */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
-    } else {
-        pQueueFamilyPropertyCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pQueueFamilyPropertyCount);
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
-            vn_decode_VkQueueFamilyProperties(dec, &pQueueFamilyProperties[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pQueueFamilyProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
-    if (pMemoryProperties)
-        cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(pMemoryProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pMemoryProperties))
-        vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, pMemoryProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
-    if (pMemoryProperties)
-        cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties(pMemoryProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT);
-
-    /* skip physicalDevice */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkPhysicalDeviceMemoryProperties(dec, pMemoryProperties);
-    } else {
-        pMemoryProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pFeatures);
-    if (pFeatures)
-        cmd_size += vn_sizeof_VkPhysicalDeviceFeatures_partial(pFeatures);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pFeatures))
-        vn_encode_VkPhysicalDeviceFeatures_partial(enc, pFeatures);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    cmd_size += vn_sizeof_simple_pointer(pFeatures);
-    if (pFeatures)
-        cmd_size += vn_sizeof_VkPhysicalDeviceFeatures(pFeatures);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT);
-
-    /* skip physicalDevice */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkPhysicalDeviceFeatures(dec, pFeatures);
-    } else {
-        pFeatures = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_VkFormat(&format);
-    cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
-    if (pFormatProperties)
-        cmd_size += vn_sizeof_VkFormatProperties_partial(pFormatProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    vn_encode_VkFormat(enc, &format);
-    if (vn_encode_simple_pointer(enc, pFormatProperties))
-        vn_encode_VkFormatProperties_partial(enc, pFormatProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    /* skip format */
-    cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
-    if (pFormatProperties)
-        cmd_size += vn_sizeof_VkFormatProperties(pFormatProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT);
-
-    /* skip physicalDevice */
-    /* skip format */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkFormatProperties(dec, pFormatProperties);
-    } else {
-        pFormatProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_VkFormat(&format);
-    cmd_size += vn_sizeof_VkImageType(&type);
-    cmd_size += vn_sizeof_VkImageTiling(&tiling);
-    cmd_size += vn_sizeof_VkFlags(&usage);
-    cmd_size += vn_sizeof_VkFlags(&flags);
-    cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
-    if (pImageFormatProperties)
-        cmd_size += vn_sizeof_VkImageFormatProperties_partial(pImageFormatProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    vn_encode_VkFormat(enc, &format);
-    vn_encode_VkImageType(enc, &type);
-    vn_encode_VkImageTiling(enc, &tiling);
-    vn_encode_VkFlags(enc, &usage);
-    vn_encode_VkFlags(enc, &flags);
-    if (vn_encode_simple_pointer(enc, pImageFormatProperties))
-        vn_encode_VkImageFormatProperties_partial(enc, pImageFormatProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip physicalDevice */
-    /* skip format */
-    /* skip type */
-    /* skip tiling */
-    /* skip usage */
-    /* skip flags */
-    cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
-    if (pImageFormatProperties)
-        cmd_size += vn_sizeof_VkImageFormatProperties(pImageFormatProperties);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip physicalDevice */
-    /* skip format */
-    /* skip type */
-    /* skip tiling */
-    /* skip usage */
-    /* skip flags */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkImageFormatProperties(dec, pImageFormatProperties);
-    } else {
-        pImageFormatProperties = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkDeviceCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pDevice);
-    if (pDevice)
-        cmd_size += vn_sizeof_VkDevice(pDevice);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkDeviceCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pDevice))
-        vn_encode_VkDevice(enc, pDevice);
-}
-
-static inline size_t vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip physicalDevice */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pDevice);
-    if (pDevice)
-        cmd_size += vn_sizeof_VkDevice(pDevice);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateDevice_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateDevice_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip physicalDevice */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkDevice(dec, pDevice);
-    } else {
-        pDevice = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyDevice_reply(VkDevice device, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder *dec, VkDevice device, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyDevice_EXT);
-
-    /* skip device */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkEnumerateInstanceVersion(uint32_t* pApiVersion)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_simple_pointer(pApiVersion); /* out */
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkEnumerateInstanceVersion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t* pApiVersion)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_simple_pointer(enc, pApiVersion); /* out */
-}
-
-static inline size_t vn_sizeof_vkEnumerateInstanceVersion_reply(uint32_t* pApiVersion)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    cmd_size += vn_sizeof_simple_pointer(pApiVersion);
-    if (pApiVersion)
-        cmd_size += vn_sizeof_uint32_t(pApiVersion);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkEnumerateInstanceVersion_reply(struct vn_cs_decoder *dec, uint32_t* pApiVersion)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pApiVersion);
-    } else {
-        pApiVersion = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkEnumerateInstanceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    if (vn_encode_simple_pointer(enc, pPropertyCount))
-        vn_encode_uint32_t(enc, pPropertyCount);
-    if (pProperties) {
-        vn_encode_array_size(enc, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_encode_VkLayerProperties_partial(enc, &pProperties[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkEnumerateInstanceLayerProperties_reply(uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkEnumerateInstanceLayerProperties_reply(struct vn_cs_decoder *dec, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pPropertyCount);
-    } else {
-        pPropertyCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_decode_VkLayerProperties(dec, &pProperties[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pProperties = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    if (pLayerName) {
-        const size_t string_size = strlen(pLayerName) + 1;
-        cmd_size += vn_sizeof_array_size(string_size);
-        cmd_size += vn_sizeof_blob_array(pLayerName, string_size);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkEnumerateInstanceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    if (pLayerName) {
-        const size_t string_size = strlen(pLayerName) + 1;
-        vn_encode_array_size(enc, string_size);
-        vn_encode_blob_array(enc, pLayerName, string_size);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (vn_encode_simple_pointer(enc, pPropertyCount))
-        vn_encode_uint32_t(enc, pPropertyCount);
-    if (pProperties) {
-        vn_encode_array_size(enc, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkEnumerateInstanceExtensionProperties_reply(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip pLayerName */
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkEnumerateInstanceExtensionProperties_reply(struct vn_cs_decoder *dec, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip pLayerName */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pPropertyCount);
-    } else {
-        pPropertyCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_decode_VkExtensionProperties(dec, &pProperties[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pProperties = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pPropertyCount))
-        vn_encode_uint32_t(enc, pPropertyCount);
-    if (pProperties) {
-        vn_encode_array_size(enc, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_encode_VkLayerProperties_partial(enc, &pProperties[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip physicalDevice */
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip physicalDevice */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pPropertyCount);
-    } else {
-        pPropertyCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_decode_VkLayerProperties(dec, &pProperties[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pProperties = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    if (pLayerName) {
-        const size_t string_size = strlen(pLayerName) + 1;
-        cmd_size += vn_sizeof_array_size(string_size);
-        cmd_size += vn_sizeof_blob_array(pLayerName, string_size);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (pLayerName) {
-        const size_t string_size = strlen(pLayerName) + 1;
-        vn_encode_array_size(enc, string_size);
-        vn_encode_blob_array(enc, pLayerName, string_size);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (vn_encode_simple_pointer(enc, pPropertyCount))
-        vn_encode_uint32_t(enc, pPropertyCount);
-    if (pProperties) {
-        vn_encode_array_size(enc, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip physicalDevice */
-    /* skip pLayerName */
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip physicalDevice */
-    /* skip pLayerName */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pPropertyCount);
-    } else {
-        pPropertyCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_decode_VkExtensionProperties(dec, &pProperties[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pProperties = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_uint32_t(&queueFamilyIndex);
-    cmd_size += vn_sizeof_uint32_t(&queueIndex);
-    cmd_size += vn_sizeof_simple_pointer(pQueue);
-    if (pQueue)
-        cmd_size += vn_sizeof_VkQueue(pQueue);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetDeviceQueue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_uint32_t(enc, &queueFamilyIndex);
-    vn_encode_uint32_t(enc, &queueIndex);
-    if (vn_encode_simple_pointer(enc, pQueue))
-        vn_encode_VkQueue(enc, pQueue);
-}
-
-static inline size_t vn_sizeof_vkGetDeviceQueue_reply(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip queueFamilyIndex */
-    /* skip queueIndex */
-    cmd_size += vn_sizeof_simple_pointer(pQueue);
-    if (pQueue)
-        cmd_size += vn_sizeof_VkQueue(pQueue);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue_EXT);
-
-    /* skip device */
-    /* skip queueFamilyIndex */
-    /* skip queueIndex */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkQueue(dec, pQueue);
-    } else {
-        pQueue = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkQueue(&queue);
-    cmd_size += vn_sizeof_uint32_t(&submitCount);
-    if (pSubmits) {
-        cmd_size += vn_sizeof_array_size(submitCount);
-        for (uint32_t i = 0; i < submitCount; i++)
-            cmd_size += vn_sizeof_VkSubmitInfo(&pSubmits[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_VkFence(&fence);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkQueueSubmit(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkQueue(enc, &queue);
-    vn_encode_uint32_t(enc, &submitCount);
-    if (pSubmits) {
-        vn_encode_array_size(enc, submitCount);
-        for (uint32_t i = 0; i < submitCount; i++)
-            vn_encode_VkSubmitInfo(enc, &pSubmits[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_VkFence(enc, &fence);
-}
-
-static inline size_t vn_sizeof_vkQueueSubmit_reply(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip queue */
-    /* skip submitCount */
-    /* skip pSubmits */
-    /* skip fence */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkQueueSubmit_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkQueueSubmit_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip queue */
-    /* skip submitCount */
-    /* skip pSubmits */
-    /* skip fence */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkQueueWaitIdle(VkQueue queue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkQueue(&queue);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkQueueWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkQueue(enc, &queue);
-}
-
-static inline size_t vn_sizeof_vkQueueWaitIdle_reply(VkQueue queue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip queue */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkQueueWaitIdle_reply(struct vn_cs_decoder *dec, VkQueue queue)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkQueueWaitIdle_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip queue */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDeviceWaitIdle(VkDevice device)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-}
-
-static inline size_t vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder *dec, VkDevice device)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pAllocateInfo);
-    if (pAllocateInfo)
-        cmd_size += vn_sizeof_VkMemoryAllocateInfo(pAllocateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pMemory);
-    if (pMemory)
-        cmd_size += vn_sizeof_VkDeviceMemory(pMemory);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkAllocateMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pAllocateInfo))
-        vn_encode_VkMemoryAllocateInfo(enc, pAllocateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pMemory))
-        vn_encode_VkDeviceMemory(enc, pMemory);
-}
-
-static inline size_t vn_sizeof_vkAllocateMemory_reply(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pAllocateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pMemory);
-    if (pMemory)
-        cmd_size += vn_sizeof_VkDeviceMemory(pMemory);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkAllocateMemory_reply(struct vn_cs_decoder *dec, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkAllocateMemory_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pAllocateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkDeviceMemory(dec, pMemory);
-    } else {
-        pMemory = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkFreeMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkDeviceMemory(enc, &memory);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkFreeMemory_reply(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip memory */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkFreeMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkFreeMemory_EXT);
-
-    /* skip device */
-    /* skip memory */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkUnmapMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkDeviceMemory(enc, &memory);
-}
-
-static inline size_t vn_sizeof_vkUnmapMemory_reply(VkDevice device, VkDeviceMemory memory)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip memory */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkUnmapMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkUnmapMemory_EXT);
-
-    /* skip device */
-    /* skip memory */
-}
-
-static inline size_t vn_sizeof_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_uint32_t(&memoryRangeCount);
-    if (pMemoryRanges) {
-        cmd_size += vn_sizeof_array_size(memoryRangeCount);
-        for (uint32_t i = 0; i < memoryRangeCount; i++)
-            cmd_size += vn_sizeof_VkMappedMemoryRange(&pMemoryRanges[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkFlushMappedMemoryRanges(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_uint32_t(enc, &memoryRangeCount);
-    if (pMemoryRanges) {
-        vn_encode_array_size(enc, memoryRangeCount);
-        for (uint32_t i = 0; i < memoryRangeCount; i++)
-            vn_encode_VkMappedMemoryRange(enc, &pMemoryRanges[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkFlushMappedMemoryRanges_reply(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip memoryRangeCount */
-    /* skip pMemoryRanges */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkFlushMappedMemoryRanges_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip memoryRangeCount */
-    /* skip pMemoryRanges */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_uint32_t(&memoryRangeCount);
-    if (pMemoryRanges) {
-        cmd_size += vn_sizeof_array_size(memoryRangeCount);
-        for (uint32_t i = 0; i < memoryRangeCount; i++)
-            cmd_size += vn_sizeof_VkMappedMemoryRange(&pMemoryRanges[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkInvalidateMappedMemoryRanges(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_uint32_t(enc, &memoryRangeCount);
-    if (pMemoryRanges) {
-        vn_encode_array_size(enc, memoryRangeCount);
-        for (uint32_t i = 0; i < memoryRangeCount; i++)
-            vn_encode_VkMappedMemoryRange(enc, &pMemoryRanges[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkInvalidateMappedMemoryRanges_reply(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip memoryRangeCount */
-    /* skip pMemoryRanges */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkInvalidateMappedMemoryRanges_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip memoryRangeCount */
-    /* skip pMemoryRanges */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
-    cmd_size += vn_sizeof_simple_pointer(pCommittedMemoryInBytes); /* out */
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetDeviceMemoryCommitment(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkDeviceMemory(enc, &memory);
-    vn_encode_simple_pointer(enc, pCommittedMemoryInBytes); /* out */
-}
-
-static inline size_t vn_sizeof_vkGetDeviceMemoryCommitment_reply(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip memory */
-    cmd_size += vn_sizeof_simple_pointer(pCommittedMemoryInBytes);
-    if (pCommittedMemoryInBytes)
-        cmd_size += vn_sizeof_VkDeviceSize(pCommittedMemoryInBytes);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetDeviceMemoryCommitment_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT);
-
-    /* skip device */
-    /* skip memory */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkDeviceSize(dec, pCommittedMemoryInBytes);
-    } else {
-        pCommittedMemoryInBytes = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkBuffer(&buffer);
-    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
-    if (pMemoryRequirements)
-        cmd_size += vn_sizeof_VkMemoryRequirements_partial(pMemoryRequirements);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetBufferMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkBuffer(enc, &buffer);
-    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
-        vn_encode_VkMemoryRequirements_partial(enc, pMemoryRequirements);
-}
-
-static inline size_t vn_sizeof_vkGetBufferMemoryRequirements_reply(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip buffer */
-    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
-    if (pMemoryRequirements)
-        cmd_size += vn_sizeof_VkMemoryRequirements(pMemoryRequirements);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetBufferMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT);
-
-    /* skip device */
-    /* skip buffer */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkMemoryRequirements(dec, pMemoryRequirements);
-    } else {
-        pMemoryRequirements = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkBuffer(&buffer);
-    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
-    cmd_size += vn_sizeof_VkDeviceSize(&memoryOffset);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkBindBufferMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkBuffer(enc, &buffer);
-    vn_encode_VkDeviceMemory(enc, &memory);
-    vn_encode_VkDeviceSize(enc, &memoryOffset);
-}
-
-static inline size_t vn_sizeof_vkBindBufferMemory_reply(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip buffer */
-    /* skip memory */
-    /* skip memoryOffset */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkBindBufferMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkBindBufferMemory_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip buffer */
-    /* skip memory */
-    /* skip memoryOffset */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkImage(&image);
-    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
-    if (pMemoryRequirements)
-        cmd_size += vn_sizeof_VkMemoryRequirements_partial(pMemoryRequirements);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkImage(enc, &image);
-    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
-        vn_encode_VkMemoryRequirements_partial(enc, pMemoryRequirements);
-}
-
-static inline size_t vn_sizeof_vkGetImageMemoryRequirements_reply(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip image */
-    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
-    if (pMemoryRequirements)
-        cmd_size += vn_sizeof_VkMemoryRequirements(pMemoryRequirements);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT);
-
-    /* skip device */
-    /* skip image */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkMemoryRequirements(dec, pMemoryRequirements);
-    } else {
-        pMemoryRequirements = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkImage(&image);
-    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
-    cmd_size += vn_sizeof_VkDeviceSize(&memoryOffset);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkBindImageMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkImage(enc, &image);
-    vn_encode_VkDeviceMemory(enc, &memory);
-    vn_encode_VkDeviceSize(enc, &memoryOffset);
-}
-
-static inline size_t vn_sizeof_vkBindImageMemory_reply(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip image */
-    /* skip memory */
-    /* skip memoryOffset */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkBindImageMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip image */
-    /* skip memory */
-    /* skip memoryOffset */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkImage(&image);
-    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
-    if (pSparseMemoryRequirementCount)
-        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
-    if (pSparseMemoryRequirements) {
-        cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount);
-        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
-            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&pSparseMemoryRequirements[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkImage(enc, &image);
-    if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
-        vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
-    if (pSparseMemoryRequirements) {
-        vn_encode_array_size(enc, *pSparseMemoryRequirementCount);
-        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
-            vn_encode_VkSparseImageMemoryRequirements_partial(enc, &pSparseMemoryRequirements[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements_reply(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip image */
-    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
-    if (pSparseMemoryRequirementCount)
-        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
-    if (pSparseMemoryRequirements) {
-        cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount);
-        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
-            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements(&pSparseMemoryRequirements[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT);
-
-    /* skip device */
-    /* skip image */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
-    } else {
-        pSparseMemoryRequirementCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pSparseMemoryRequirementCount);
-        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
-            vn_decode_VkSparseImageMemoryRequirements(dec, &pSparseMemoryRequirements[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pSparseMemoryRequirements = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_VkFormat(&format);
-    cmd_size += vn_sizeof_VkImageType(&type);
-    cmd_size += vn_sizeof_VkSampleCountFlagBits(&samples);
-    cmd_size += vn_sizeof_VkFlags(&usage);
-    cmd_size += vn_sizeof_VkImageTiling(&tiling);
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkSparseImageFormatProperties_partial(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    vn_encode_VkFormat(enc, &format);
-    vn_encode_VkImageType(enc, &type);
-    vn_encode_VkSampleCountFlagBits(enc, &samples);
-    vn_encode_VkFlags(enc, &usage);
-    vn_encode_VkImageTiling(enc, &tiling);
-    if (vn_encode_simple_pointer(enc, pPropertyCount))
-        vn_encode_uint32_t(enc, pPropertyCount);
-    if (pProperties) {
-        vn_encode_array_size(enc, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_encode_VkSparseImageFormatProperties_partial(enc, &pProperties[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    /* skip format */
-    /* skip type */
-    /* skip samples */
-    /* skip usage */
-    /* skip tiling */
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkSparseImageFormatProperties(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT);
-
-    /* skip physicalDevice */
-    /* skip format */
-    /* skip type */
-    /* skip samples */
-    /* skip usage */
-    /* skip tiling */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pPropertyCount);
-    } else {
-        pPropertyCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_decode_VkSparseImageFormatProperties(dec, &pProperties[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkQueue(&queue);
-    cmd_size += vn_sizeof_uint32_t(&bindInfoCount);
-    if (pBindInfo) {
-        cmd_size += vn_sizeof_array_size(bindInfoCount);
-        for (uint32_t i = 0; i < bindInfoCount; i++)
-            cmd_size += vn_sizeof_VkBindSparseInfo(&pBindInfo[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_VkFence(&fence);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkQueueBindSparse(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkQueue(enc, &queue);
-    vn_encode_uint32_t(enc, &bindInfoCount);
-    if (pBindInfo) {
-        vn_encode_array_size(enc, bindInfoCount);
-        for (uint32_t i = 0; i < bindInfoCount; i++)
-            vn_encode_VkBindSparseInfo(enc, &pBindInfo[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_VkFence(enc, &fence);
-}
-
-static inline size_t vn_sizeof_vkQueueBindSparse_reply(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip queue */
-    /* skip bindInfoCount */
-    /* skip pBindInfo */
-    /* skip fence */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkQueueBindSparse_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkQueueBindSparse_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip queue */
-    /* skip bindInfoCount */
-    /* skip pBindInfo */
-    /* skip fence */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkFenceCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pFence);
-    if (pFence)
-        cmd_size += vn_sizeof_VkFence(pFence);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateFence(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkFenceCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pFence))
-        vn_encode_VkFence(enc, pFence);
-}
-
-static inline size_t vn_sizeof_vkCreateFence_reply(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pFence);
-    if (pFence)
-        cmd_size += vn_sizeof_VkFence(pFence);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateFence_reply(struct vn_cs_decoder *dec, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateFence_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkFence(dec, pFence);
-    } else {
-        pFence = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkFence(&fence);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyFence(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkFence(enc, &fence);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyFence_reply(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip fence */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyFence_reply(struct vn_cs_decoder *dec, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyFence_EXT);
-
-    /* skip device */
-    /* skip fence */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_uint32_t(&fenceCount);
-    if (pFences) {
-        cmd_size += vn_sizeof_array_size(fenceCount);
-        for (uint32_t i = 0; i < fenceCount; i++)
-            cmd_size += vn_sizeof_VkFence(&pFences[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkResetFences(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_uint32_t(enc, &fenceCount);
-    if (pFences) {
-        vn_encode_array_size(enc, fenceCount);
-        for (uint32_t i = 0; i < fenceCount; i++)
-            vn_encode_VkFence(enc, &pFences[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkResetFences_reply(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip fenceCount */
-    /* skip pFences */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkResetFences_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkResetFences_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip fenceCount */
-    /* skip pFences */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetFenceStatus(VkDevice device, VkFence fence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkFence(&fence);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetFenceStatus(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkFence(enc, &fence);
-}
-
-static inline size_t vn_sizeof_vkGetFenceStatus_reply(VkDevice device, VkFence fence)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip fence */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkGetFenceStatus_reply(struct vn_cs_decoder *dec, VkDevice device, VkFence fence)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetFenceStatus_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip fence */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_uint32_t(&fenceCount);
-    if (pFences) {
-        cmd_size += vn_sizeof_array_size(fenceCount);
-        for (uint32_t i = 0; i < fenceCount; i++)
-            cmd_size += vn_sizeof_VkFence(&pFences[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_VkBool32(&waitAll);
-    cmd_size += vn_sizeof_uint64_t(&timeout);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkWaitForFences(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_uint32_t(enc, &fenceCount);
-    if (pFences) {
-        vn_encode_array_size(enc, fenceCount);
-        for (uint32_t i = 0; i < fenceCount; i++)
-            vn_encode_VkFence(enc, &pFences[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_VkBool32(enc, &waitAll);
-    vn_encode_uint64_t(enc, &timeout);
-}
-
-static inline size_t vn_sizeof_vkWaitForFences_reply(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip fenceCount */
-    /* skip pFences */
-    /* skip waitAll */
-    /* skip timeout */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkWaitForFences_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkWaitForFences_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip fenceCount */
-    /* skip pFences */
-    /* skip waitAll */
-    /* skip timeout */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkSemaphoreCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pSemaphore);
-    if (pSemaphore)
-        cmd_size += vn_sizeof_VkSemaphore(pSemaphore);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateSemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkSemaphoreCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pSemaphore))
-        vn_encode_VkSemaphore(enc, pSemaphore);
-}
-
-static inline size_t vn_sizeof_vkCreateSemaphore_reply(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pSemaphore);
-    if (pSemaphore)
-        cmd_size += vn_sizeof_VkSemaphore(pSemaphore);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateSemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateSemaphore_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkSemaphore(dec, pSemaphore);
-    } else {
-        pSemaphore = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkSemaphore(&semaphore);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroySemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkSemaphore(enc, &semaphore);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroySemaphore_reply(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip semaphore */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroySemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroySemaphore_EXT);
-
-    /* skip device */
-    /* skip semaphore */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkEventCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pEvent);
-    if (pEvent)
-        cmd_size += vn_sizeof_VkEvent(pEvent);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkEventCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pEvent))
-        vn_encode_VkEvent(enc, pEvent);
-}
-
-static inline size_t vn_sizeof_vkCreateEvent_reply(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pEvent);
-    if (pEvent)
-        cmd_size += vn_sizeof_VkEvent(pEvent);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateEvent_reply(struct vn_cs_decoder *dec, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateEvent_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkEvent(dec, pEvent);
-    } else {
-        pEvent = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkEvent(&event);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkEvent(enc, &event);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyEvent_reply(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip event */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyEvent_EXT);
-
-    /* skip device */
-    /* skip event */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkGetEventStatus(VkDevice device, VkEvent event)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkEvent(&event);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetEventStatus(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkEvent(enc, &event);
-}
-
-static inline size_t vn_sizeof_vkGetEventStatus_reply(VkDevice device, VkEvent event)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip event */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkGetEventStatus_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetEventStatus_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip event */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkSetEvent(VkDevice device, VkEvent event)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkEvent(&event);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkSetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkEvent(enc, &event);
-}
-
-static inline size_t vn_sizeof_vkSetEvent_reply(VkDevice device, VkEvent event)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip event */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkSetEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkSetEvent_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip event */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkResetEvent(VkDevice device, VkEvent event)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkEvent(&event);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkResetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkEvent(enc, &event);
-}
-
-static inline size_t vn_sizeof_vkResetEvent_reply(VkDevice device, VkEvent event)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip event */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkResetEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkResetEvent_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip event */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkQueryPoolCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pQueryPool);
-    if (pQueryPool)
-        cmd_size += vn_sizeof_VkQueryPool(pQueryPool);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkQueryPoolCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pQueryPool))
-        vn_encode_VkQueryPool(enc, pQueryPool);
-}
-
-static inline size_t vn_sizeof_vkCreateQueryPool_reply(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pQueryPool);
-    if (pQueryPool)
-        cmd_size += vn_sizeof_VkQueryPool(pQueryPool);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateQueryPool_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkQueryPool(dec, pQueryPool);
-    } else {
-        pQueryPool = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkQueryPool(enc, &queryPool);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyQueryPool_reply(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip queryPool */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyQueryPool_EXT);
-
-    /* skip device */
-    /* skip queryPool */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
-    cmd_size += vn_sizeof_uint32_t(&firstQuery);
-    cmd_size += vn_sizeof_uint32_t(&queryCount);
-    cmd_size += vn_sizeof_size_t(&dataSize);
-    cmd_size += vn_sizeof_simple_pointer(pData); /* out */
-    cmd_size += vn_sizeof_VkDeviceSize(&stride);
-    cmd_size += vn_sizeof_VkFlags(&flags);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetQueryPoolResults(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkQueryPool(enc, &queryPool);
-    vn_encode_uint32_t(enc, &firstQuery);
-    vn_encode_uint32_t(enc, &queryCount);
-    vn_encode_size_t(enc, &dataSize);
-    vn_encode_array_size(enc, pData ? dataSize : 0); /* out */
-    vn_encode_VkDeviceSize(enc, &stride);
-    vn_encode_VkFlags(enc, &flags);
-}
-
-static inline size_t vn_sizeof_vkGetQueryPoolResults_reply(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip queryPool */
-    /* skip firstQuery */
-    /* skip queryCount */
-    /* skip dataSize */
-    if (pData) {
-        cmd_size += vn_sizeof_array_size(dataSize);
-        cmd_size += vn_sizeof_blob_array(pData, dataSize);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    /* skip stride */
-    /* skip flags */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkGetQueryPoolResults_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip queryPool */
-    /* skip firstQuery */
-    /* skip queryCount */
-    /* skip dataSize */
-    if (vn_peek_array_size(dec)) {
-        const size_t array_size = vn_decode_array_size(dec, dataSize);
-        vn_decode_blob_array(dec, pData, array_size);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pData = NULL;
-    }
-    /* skip stride */
-    /* skip flags */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
-    cmd_size += vn_sizeof_uint32_t(&firstQuery);
-    cmd_size += vn_sizeof_uint32_t(&queryCount);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkResetQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkQueryPool(enc, &queryPool);
-    vn_encode_uint32_t(enc, &firstQuery);
-    vn_encode_uint32_t(enc, &queryCount);
-}
-
-static inline size_t vn_sizeof_vkResetQueryPool_reply(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip queryPool */
-    /* skip firstQuery */
-    /* skip queryCount */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkResetQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkResetQueryPool_EXT);
-
-    /* skip device */
-    /* skip queryPool */
-    /* skip firstQuery */
-    /* skip queryCount */
-}
-
-static inline size_t vn_sizeof_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkBufferCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pBuffer);
-    if (pBuffer)
-        cmd_size += vn_sizeof_VkBuffer(pBuffer);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkBufferCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pBuffer))
-        vn_encode_VkBuffer(enc, pBuffer);
-}
-
-static inline size_t vn_sizeof_vkCreateBuffer_reply(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pBuffer);
-    if (pBuffer)
-        cmd_size += vn_sizeof_VkBuffer(pBuffer);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateBuffer_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateBuffer_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkBuffer(dec, pBuffer);
-    } else {
-        pBuffer = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkBuffer(&buffer);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkBuffer(enc, &buffer);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyBuffer_reply(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip buffer */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyBuffer_reply(struct vn_cs_decoder *dec, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyBuffer_EXT);
-
-    /* skip device */
-    /* skip buffer */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkBufferViewCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pView);
-    if (pView)
-        cmd_size += vn_sizeof_VkBufferView(pView);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateBufferView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkBufferViewCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pView))
-        vn_encode_VkBufferView(enc, pView);
-}
-
-static inline size_t vn_sizeof_vkCreateBufferView_reply(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pView);
-    if (pView)
-        cmd_size += vn_sizeof_VkBufferView(pView);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateBufferView_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateBufferView_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkBufferView(dec, pView);
-    } else {
-        pView = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkBufferView(&bufferView);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyBufferView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkBufferView(enc, &bufferView);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyBufferView_reply(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip bufferView */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyBufferView_reply(struct vn_cs_decoder *dec, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyBufferView_EXT);
-
-    /* skip device */
-    /* skip bufferView */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkImageCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pImage);
-    if (pImage)
-        cmd_size += vn_sizeof_VkImage(pImage);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkImageCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pImage))
-        vn_encode_VkImage(enc, pImage);
-}
-
-static inline size_t vn_sizeof_vkCreateImage_reply(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pImage);
-    if (pImage)
-        cmd_size += vn_sizeof_VkImage(pImage);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateImage_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateImage_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkImage(dec, pImage);
-    } else {
-        pImage = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkImage(&image);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkImage(enc, &image);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyImage_reply(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip image */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyImage_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyImage_EXT);
-
-    /* skip device */
-    /* skip image */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkImage(&image);
-    cmd_size += vn_sizeof_simple_pointer(pSubresource);
-    if (pSubresource)
-        cmd_size += vn_sizeof_VkImageSubresource(pSubresource);
-    cmd_size += vn_sizeof_simple_pointer(pLayout);
-    if (pLayout)
-        cmd_size += vn_sizeof_VkSubresourceLayout_partial(pLayout);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetImageSubresourceLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkImage(enc, &image);
-    if (vn_encode_simple_pointer(enc, pSubresource))
-        vn_encode_VkImageSubresource(enc, pSubresource);
-    if (vn_encode_simple_pointer(enc, pLayout))
-        vn_encode_VkSubresourceLayout_partial(enc, pLayout);
-}
-
-static inline size_t vn_sizeof_vkGetImageSubresourceLayout_reply(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip image */
-    /* skip pSubresource */
-    cmd_size += vn_sizeof_simple_pointer(pLayout);
-    if (pLayout)
-        cmd_size += vn_sizeof_VkSubresourceLayout(pLayout);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetImageSubresourceLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT);
-
-    /* skip device */
-    /* skip image */
-    /* skip pSubresource */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkSubresourceLayout(dec, pLayout);
-    } else {
-        pLayout = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkImageViewCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pView);
-    if (pView)
-        cmd_size += vn_sizeof_VkImageView(pView);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateImageView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkImageViewCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pView))
-        vn_encode_VkImageView(enc, pView);
-}
-
-static inline size_t vn_sizeof_vkCreateImageView_reply(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pView);
-    if (pView)
-        cmd_size += vn_sizeof_VkImageView(pView);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateImageView_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateImageView_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkImageView(dec, pView);
-    } else {
-        pView = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkImageView(&imageView);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyImageView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkImageView(enc, &imageView);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyImageView_reply(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip imageView */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyImageView_reply(struct vn_cs_decoder *dec, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyImageView_EXT);
-
-    /* skip device */
-    /* skip imageView */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkShaderModuleCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pShaderModule);
-    if (pShaderModule)
-        cmd_size += vn_sizeof_VkShaderModule(pShaderModule);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateShaderModule(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkShaderModuleCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pShaderModule))
-        vn_encode_VkShaderModule(enc, pShaderModule);
-}
-
-static inline size_t vn_sizeof_vkCreateShaderModule_reply(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pShaderModule);
-    if (pShaderModule)
-        cmd_size += vn_sizeof_VkShaderModule(pShaderModule);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateShaderModule_reply(struct vn_cs_decoder *dec, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateShaderModule_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkShaderModule(dec, pShaderModule);
-    } else {
-        pShaderModule = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkShaderModule(&shaderModule);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyShaderModule(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkShaderModule(enc, &shaderModule);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyShaderModule_reply(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip shaderModule */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyShaderModule_reply(struct vn_cs_decoder *dec, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyShaderModule_EXT);
-
-    /* skip device */
-    /* skip shaderModule */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkPipelineCacheCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pPipelineCache);
-    if (pPipelineCache)
-        cmd_size += vn_sizeof_VkPipelineCache(pPipelineCache);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreatePipelineCache(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkPipelineCacheCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pPipelineCache))
-        vn_encode_VkPipelineCache(enc, pPipelineCache);
-}
-
-static inline size_t vn_sizeof_vkCreatePipelineCache_reply(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pPipelineCache);
-    if (pPipelineCache)
-        cmd_size += vn_sizeof_VkPipelineCache(pPipelineCache);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreatePipelineCache_reply(struct vn_cs_decoder *dec, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreatePipelineCache_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkPipelineCache(dec, pPipelineCache);
-    } else {
-        pPipelineCache = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyPipelineCache(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkPipelineCache(enc, &pipelineCache);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyPipelineCache_reply(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip pipelineCache */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyPipelineCache_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT);
-
-    /* skip device */
-    /* skip pipelineCache */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
-    cmd_size += vn_sizeof_simple_pointer(pDataSize);
-    if (pDataSize)
-        cmd_size += vn_sizeof_size_t(pDataSize);
-    cmd_size += vn_sizeof_simple_pointer(pData); /* out */
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPipelineCacheData(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkPipelineCache(enc, &pipelineCache);
-    if (vn_encode_simple_pointer(enc, pDataSize))
-        vn_encode_size_t(enc, pDataSize);
-    vn_encode_array_size(enc, pData ? *pDataSize : 0); /* out */
-}
-
-static inline size_t vn_sizeof_vkGetPipelineCacheData_reply(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pipelineCache */
-    cmd_size += vn_sizeof_simple_pointer(pDataSize);
-    if (pDataSize)
-        cmd_size += vn_sizeof_size_t(pDataSize);
-    if (pData) {
-        cmd_size += vn_sizeof_array_size(*pDataSize);
-        cmd_size += vn_sizeof_blob_array(pData, *pDataSize);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkGetPipelineCacheData_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pipelineCache */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_size_t(dec, pDataSize);
-    } else {
-        pDataSize = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        const size_t array_size = vn_decode_array_size(dec, *pDataSize);
-        vn_decode_blob_array(dec, pData, array_size);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pData = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkPipelineCache(&dstCache);
-    cmd_size += vn_sizeof_uint32_t(&srcCacheCount);
-    if (pSrcCaches) {
-        cmd_size += vn_sizeof_array_size(srcCacheCount);
-        for (uint32_t i = 0; i < srcCacheCount; i++)
-            cmd_size += vn_sizeof_VkPipelineCache(&pSrcCaches[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkMergePipelineCaches(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkPipelineCache(enc, &dstCache);
-    vn_encode_uint32_t(enc, &srcCacheCount);
-    if (pSrcCaches) {
-        vn_encode_array_size(enc, srcCacheCount);
-        for (uint32_t i = 0; i < srcCacheCount; i++)
-            vn_encode_VkPipelineCache(enc, &pSrcCaches[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkMergePipelineCaches_reply(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip dstCache */
-    /* skip srcCacheCount */
-    /* skip pSrcCaches */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkMergePipelineCaches_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkMergePipelineCaches_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip dstCache */
-    /* skip srcCacheCount */
-    /* skip pSrcCaches */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
-    cmd_size += vn_sizeof_uint32_t(&createInfoCount);
-    if (pCreateInfos) {
-        cmd_size += vn_sizeof_array_size(createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            cmd_size += vn_sizeof_VkGraphicsPipelineCreateInfo(&pCreateInfos[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    if (pPipelines) {
-        cmd_size += vn_sizeof_array_size(createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateGraphicsPipelines(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkPipelineCache(enc, &pipelineCache);
-    vn_encode_uint32_t(enc, &createInfoCount);
-    if (pCreateInfos) {
-        vn_encode_array_size(enc, createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            vn_encode_VkGraphicsPipelineCreateInfo(enc, &pCreateInfos[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (pPipelines) {
-        vn_encode_array_size(enc, createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            vn_encode_VkPipeline(enc, &pPipelines[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCreateGraphicsPipelines_reply(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pipelineCache */
-    /* skip createInfoCount */
-    /* skip pCreateInfos */
-    /* skip pAllocator */
-    if (pPipelines) {
-        cmd_size += vn_sizeof_array_size(createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateGraphicsPipelines_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pipelineCache */
-    /* skip createInfoCount */
-    /* skip pCreateInfos */
-    /* skip pAllocator */
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            vn_decode_VkPipeline(dec, &pPipelines[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pPipelines = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
-    cmd_size += vn_sizeof_uint32_t(&createInfoCount);
-    if (pCreateInfos) {
-        cmd_size += vn_sizeof_array_size(createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            cmd_size += vn_sizeof_VkComputePipelineCreateInfo(&pCreateInfos[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    if (pPipelines) {
-        cmd_size += vn_sizeof_array_size(createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateComputePipelines(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkPipelineCache(enc, &pipelineCache);
-    vn_encode_uint32_t(enc, &createInfoCount);
-    if (pCreateInfos) {
-        vn_encode_array_size(enc, createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            vn_encode_VkComputePipelineCreateInfo(enc, &pCreateInfos[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (pPipelines) {
-        vn_encode_array_size(enc, createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            vn_encode_VkPipeline(enc, &pPipelines[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCreateComputePipelines_reply(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pipelineCache */
-    /* skip createInfoCount */
-    /* skip pCreateInfos */
-    /* skip pAllocator */
-    if (pPipelines) {
-        cmd_size += vn_sizeof_array_size(createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateComputePipelines_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateComputePipelines_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pipelineCache */
-    /* skip createInfoCount */
-    /* skip pCreateInfos */
-    /* skip pAllocator */
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            vn_decode_VkPipeline(dec, &pPipelines[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pPipelines = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkPipeline(&pipeline);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyPipeline(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkPipeline(enc, &pipeline);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyPipeline_reply(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip pipeline */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyPipeline_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyPipeline_EXT);
-
-    /* skip device */
-    /* skip pipeline */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkPipelineLayoutCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pPipelineLayout);
-    if (pPipelineLayout)
-        cmd_size += vn_sizeof_VkPipelineLayout(pPipelineLayout);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreatePipelineLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkPipelineLayoutCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pPipelineLayout))
-        vn_encode_VkPipelineLayout(enc, pPipelineLayout);
-}
-
-static inline size_t vn_sizeof_vkCreatePipelineLayout_reply(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pPipelineLayout);
-    if (pPipelineLayout)
-        cmd_size += vn_sizeof_VkPipelineLayout(pPipelineLayout);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreatePipelineLayout_reply(struct vn_cs_decoder *dec, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkPipelineLayout(dec, pPipelineLayout);
-    } else {
-        pPipelineLayout = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkPipelineLayout(&pipelineLayout);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyPipelineLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkPipelineLayout(enc, &pipelineLayout);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyPipelineLayout_reply(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip pipelineLayout */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyPipelineLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT);
-
-    /* skip device */
-    /* skip pipelineLayout */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkSamplerCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pSampler);
-    if (pSampler)
-        cmd_size += vn_sizeof_VkSampler(pSampler);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateSampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkSamplerCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pSampler))
-        vn_encode_VkSampler(enc, pSampler);
-}
-
-static inline size_t vn_sizeof_vkCreateSampler_reply(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pSampler);
-    if (pSampler)
-        cmd_size += vn_sizeof_VkSampler(pSampler);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateSampler_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateSampler_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkSampler(dec, pSampler);
-    } else {
-        pSampler = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkSampler(&sampler);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroySampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkSampler(enc, &sampler);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroySampler_reply(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip sampler */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroySampler_reply(struct vn_cs_decoder *dec, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroySampler_EXT);
-
-    /* skip device */
-    /* skip sampler */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkDescriptorSetLayoutCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pSetLayout);
-    if (pSetLayout)
-        cmd_size += vn_sizeof_VkDescriptorSetLayout(pSetLayout);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateDescriptorSetLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkDescriptorSetLayoutCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pSetLayout))
-        vn_encode_VkDescriptorSetLayout(enc, pSetLayout);
-}
-
-static inline size_t vn_sizeof_vkCreateDescriptorSetLayout_reply(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pSetLayout);
-    if (pSetLayout)
-        cmd_size += vn_sizeof_VkDescriptorSetLayout(pSetLayout);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateDescriptorSetLayout_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkDescriptorSetLayout(dec, pSetLayout);
-    } else {
-        pSetLayout = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkDescriptorSetLayout(&descriptorSetLayout);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyDescriptorSetLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkDescriptorSetLayout(enc, &descriptorSetLayout);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyDescriptorSetLayout_reply(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip descriptorSetLayout */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyDescriptorSetLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT);
-
-    /* skip device */
-    /* skip descriptorSetLayout */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkDescriptorPoolCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pDescriptorPool);
-    if (pDescriptorPool)
-        cmd_size += vn_sizeof_VkDescriptorPool(pDescriptorPool);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkDescriptorPoolCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pDescriptorPool))
-        vn_encode_VkDescriptorPool(enc, pDescriptorPool);
-}
-
-static inline size_t vn_sizeof_vkCreateDescriptorPool_reply(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pDescriptorPool);
-    if (pDescriptorPool)
-        cmd_size += vn_sizeof_VkDescriptorPool(pDescriptorPool);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkDescriptorPool(dec, pDescriptorPool);
-    } else {
-        pDescriptorPool = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkDescriptorPool(enc, &descriptorPool);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyDescriptorPool_reply(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip descriptorPool */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT);
-
-    /* skip device */
-    /* skip descriptorPool */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
-    cmd_size += vn_sizeof_VkFlags(&flags);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkResetDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkDescriptorPool(enc, &descriptorPool);
-    vn_encode_VkFlags(enc, &flags);
-}
-
-static inline size_t vn_sizeof_vkResetDescriptorPool_reply(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip descriptorPool */
-    /* skip flags */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkResetDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkResetDescriptorPool_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip descriptorPool */
-    /* skip flags */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pAllocateInfo);
-    if (pAllocateInfo)
-        cmd_size += vn_sizeof_VkDescriptorSetAllocateInfo(pAllocateInfo);
-    if (pDescriptorSets) {
-        cmd_size += vn_sizeof_array_size(pAllocateInfo->descriptorSetCount);
-        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
-            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkAllocateDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pAllocateInfo))
-        vn_encode_VkDescriptorSetAllocateInfo(enc, pAllocateInfo);
-    if (pDescriptorSets) {
-        vn_encode_array_size(enc, pAllocateInfo->descriptorSetCount);
-        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
-            vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkAllocateDescriptorSets_reply(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pAllocateInfo */
-    if (pDescriptorSets) {
-        cmd_size += vn_sizeof_array_size(pAllocateInfo->descriptorSetCount);
-        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
-            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkAllocateDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pAllocateInfo */
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, pAllocateInfo->descriptorSetCount);
-        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
-            vn_decode_VkDescriptorSet(dec, &pDescriptorSets[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pDescriptorSets = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
-    cmd_size += vn_sizeof_uint32_t(&descriptorSetCount);
-    if (pDescriptorSets) {
-        cmd_size += vn_sizeof_array_size(descriptorSetCount);
-        for (uint32_t i = 0; i < descriptorSetCount; i++)
-            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkFreeDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkDescriptorPool(enc, &descriptorPool);
-    vn_encode_uint32_t(enc, &descriptorSetCount);
-    if (pDescriptorSets) {
-        vn_encode_array_size(enc, descriptorSetCount);
-        for (uint32_t i = 0; i < descriptorSetCount; i++)
-            vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkFreeDescriptorSets_reply(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip descriptorPool */
-    /* skip descriptorSetCount */
-    /* skip pDescriptorSets */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkFreeDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip descriptorPool */
-    /* skip descriptorSetCount */
-    /* skip pDescriptorSets */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_uint32_t(&descriptorWriteCount);
-    if (pDescriptorWrites) {
-        cmd_size += vn_sizeof_array_size(descriptorWriteCount);
-        for (uint32_t i = 0; i < descriptorWriteCount; i++)
-            cmd_size += vn_sizeof_VkWriteDescriptorSet(&pDescriptorWrites[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_uint32_t(&descriptorCopyCount);
-    if (pDescriptorCopies) {
-        cmd_size += vn_sizeof_array_size(descriptorCopyCount);
-        for (uint32_t i = 0; i < descriptorCopyCount; i++)
-            cmd_size += vn_sizeof_VkCopyDescriptorSet(&pDescriptorCopies[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkUpdateDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_uint32_t(enc, &descriptorWriteCount);
-    if (pDescriptorWrites) {
-        vn_encode_array_size(enc, descriptorWriteCount);
-        for (uint32_t i = 0; i < descriptorWriteCount; i++)
-            vn_encode_VkWriteDescriptorSet(enc, &pDescriptorWrites[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &descriptorCopyCount);
-    if (pDescriptorCopies) {
-        vn_encode_array_size(enc, descriptorCopyCount);
-        for (uint32_t i = 0; i < descriptorCopyCount; i++)
-            vn_encode_VkCopyDescriptorSet(enc, &pDescriptorCopies[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkUpdateDescriptorSets_reply(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip descriptorWriteCount */
-    /* skip pDescriptorWrites */
-    /* skip descriptorCopyCount */
-    /* skip pDescriptorCopies */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkUpdateDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT);
-
-    /* skip device */
-    /* skip descriptorWriteCount */
-    /* skip pDescriptorWrites */
-    /* skip descriptorCopyCount */
-    /* skip pDescriptorCopies */
-}
-
-static inline size_t vn_sizeof_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkFramebufferCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pFramebuffer);
-    if (pFramebuffer)
-        cmd_size += vn_sizeof_VkFramebuffer(pFramebuffer);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateFramebuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkFramebufferCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pFramebuffer))
-        vn_encode_VkFramebuffer(enc, pFramebuffer);
-}
-
-static inline size_t vn_sizeof_vkCreateFramebuffer_reply(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pFramebuffer);
-    if (pFramebuffer)
-        cmd_size += vn_sizeof_VkFramebuffer(pFramebuffer);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateFramebuffer_reply(struct vn_cs_decoder *dec, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateFramebuffer_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkFramebuffer(dec, pFramebuffer);
-    } else {
-        pFramebuffer = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkFramebuffer(&framebuffer);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyFramebuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkFramebuffer(enc, &framebuffer);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyFramebuffer_reply(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip framebuffer */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyFramebuffer_reply(struct vn_cs_decoder *dec, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT);
-
-    /* skip device */
-    /* skip framebuffer */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkRenderPassCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
-    if (pRenderPass)
-        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkRenderPassCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pRenderPass))
-        vn_encode_VkRenderPass(enc, pRenderPass);
-}
-
-static inline size_t vn_sizeof_vkCreateRenderPass_reply(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
-    if (pRenderPass)
-        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkRenderPass(dec, pRenderPass);
-    } else {
-        pRenderPass = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkRenderPass(&renderPass);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkRenderPass(enc, &renderPass);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyRenderPass_reply(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip renderPass */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyRenderPass_EXT);
-
-    /* skip device */
-    /* skip renderPass */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkRenderPass(&renderPass);
-    cmd_size += vn_sizeof_simple_pointer(pGranularity);
-    if (pGranularity)
-        cmd_size += vn_sizeof_VkExtent2D_partial(pGranularity);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetRenderAreaGranularity(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkRenderPass(enc, &renderPass);
-    if (vn_encode_simple_pointer(enc, pGranularity))
-        vn_encode_VkExtent2D_partial(enc, pGranularity);
-}
-
-static inline size_t vn_sizeof_vkGetRenderAreaGranularity_reply(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip renderPass */
-    cmd_size += vn_sizeof_simple_pointer(pGranularity);
-    if (pGranularity)
-        cmd_size += vn_sizeof_VkExtent2D(pGranularity);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetRenderAreaGranularity_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT);
-
-    /* skip device */
-    /* skip renderPass */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkExtent2D(dec, pGranularity);
-    } else {
-        pGranularity = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkCommandPoolCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pCommandPool);
-    if (pCommandPool)
-        cmd_size += vn_sizeof_VkCommandPool(pCommandPool);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkCommandPoolCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pCommandPool))
-        vn_encode_VkCommandPool(enc, pCommandPool);
-}
-
-static inline size_t vn_sizeof_vkCreateCommandPool_reply(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pCommandPool);
-    if (pCommandPool)
-        cmd_size += vn_sizeof_VkCommandPool(pCommandPool);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateCommandPool_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkCommandPool(dec, pCommandPool);
-    } else {
-        pCommandPool = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkCommandPool(enc, &commandPool);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyCommandPool_reply(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip commandPool */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyCommandPool_EXT);
-
-    /* skip device */
-    /* skip commandPool */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
-    cmd_size += vn_sizeof_VkFlags(&flags);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkResetCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkCommandPool(enc, &commandPool);
-    vn_encode_VkFlags(enc, &flags);
-}
-
-static inline size_t vn_sizeof_vkResetCommandPool_reply(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip commandPool */
-    /* skip flags */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkResetCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkResetCommandPool_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip commandPool */
-    /* skip flags */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pAllocateInfo);
-    if (pAllocateInfo)
-        cmd_size += vn_sizeof_VkCommandBufferAllocateInfo(pAllocateInfo);
-    if (pCommandBuffers) {
-        cmd_size += vn_sizeof_array_size(pAllocateInfo->commandBufferCount);
-        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++)
-            cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkAllocateCommandBuffers(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pAllocateInfo))
-        vn_encode_VkCommandBufferAllocateInfo(enc, pAllocateInfo);
-    if (pCommandBuffers) {
-        vn_encode_array_size(enc, pAllocateInfo->commandBufferCount);
-        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++)
-            vn_encode_VkCommandBuffer(enc, &pCommandBuffers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkAllocateCommandBuffers_reply(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pAllocateInfo */
-    if (pCommandBuffers) {
-        cmd_size += vn_sizeof_array_size(pAllocateInfo->commandBufferCount);
-        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++)
-            cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkAllocateCommandBuffers_reply(struct vn_cs_decoder *dec, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pAllocateInfo */
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, pAllocateInfo->commandBufferCount);
-        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++)
-            vn_decode_VkCommandBuffer(dec, &pCommandBuffers[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pCommandBuffers = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
-    cmd_size += vn_sizeof_uint32_t(&commandBufferCount);
-    if (pCommandBuffers) {
-        cmd_size += vn_sizeof_array_size(commandBufferCount);
-        for (uint32_t i = 0; i < commandBufferCount; i++)
-            cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkFreeCommandBuffers(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkCommandPool(enc, &commandPool);
-    vn_encode_uint32_t(enc, &commandBufferCount);
-    if (pCommandBuffers) {
-        vn_encode_array_size(enc, commandBufferCount);
-        for (uint32_t i = 0; i < commandBufferCount; i++)
-            vn_encode_VkCommandBuffer(enc, &pCommandBuffers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkFreeCommandBuffers_reply(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip commandPool */
-    /* skip commandBufferCount */
-    /* skip pCommandBuffers */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkFreeCommandBuffers_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT);
-
-    /* skip device */
-    /* skip commandPool */
-    /* skip commandBufferCount */
-    /* skip pCommandBuffers */
-}
-
-static inline size_t vn_sizeof_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_simple_pointer(pBeginInfo);
-    if (pBeginInfo)
-        cmd_size += vn_sizeof_VkCommandBufferBeginInfo(pBeginInfo);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkBeginCommandBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    if (vn_encode_simple_pointer(enc, pBeginInfo))
-        vn_encode_VkCommandBufferBeginInfo(enc, pBeginInfo);
-}
-
-static inline size_t vn_sizeof_vkBeginCommandBuffer_reply(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip commandBuffer */
-    /* skip pBeginInfo */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkBeginCommandBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip commandBuffer */
-    /* skip pBeginInfo */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEndCommandBuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkEndCommandBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEndCommandBuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-}
-
-static inline size_t vn_sizeof_vkEndCommandBuffer_reply(VkCommandBuffer commandBuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEndCommandBuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip commandBuffer */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkEndCommandBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkEndCommandBuffer_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip commandBuffer */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandBuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkFlags(&flags);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkResetCommandBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandBuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkFlags(enc, &flags);
-}
-
-static inline size_t vn_sizeof_vkResetCommandBuffer_reply(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandBuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip commandBuffer */
-    /* skip flags */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkResetCommandBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkResetCommandBuffer_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip commandBuffer */
-    /* skip flags */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindPipeline_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkPipelineBindPoint(&pipelineBindPoint);
-    cmd_size += vn_sizeof_VkPipeline(&pipeline);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBindPipeline(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindPipeline_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkPipelineBindPoint(enc, &pipelineBindPoint);
-    vn_encode_VkPipeline(enc, &pipeline);
-}
-
-static inline size_t vn_sizeof_vkCmdBindPipeline_reply(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindPipeline_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip pipelineBindPoint */
-    /* skip pipeline */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBindPipeline_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBindPipeline_EXT);
-
-    /* skip commandBuffer */
-    /* skip pipelineBindPoint */
-    /* skip pipeline */
-}
-
-static inline size_t vn_sizeof_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewport_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&firstViewport);
-    cmd_size += vn_sizeof_uint32_t(&viewportCount);
-    if (pViewports) {
-        cmd_size += vn_sizeof_array_size(viewportCount);
-        for (uint32_t i = 0; i < viewportCount; i++)
-            cmd_size += vn_sizeof_VkViewport(&pViewports[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetViewport(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewport_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &firstViewport);
-    vn_encode_uint32_t(enc, &viewportCount);
-    if (pViewports) {
-        vn_encode_array_size(enc, viewportCount);
-        for (uint32_t i = 0; i < viewportCount; i++)
-            vn_encode_VkViewport(enc, &pViewports[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdSetViewport_reply(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewport_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip firstViewport */
-    /* skip viewportCount */
-    /* skip pViewports */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetViewport_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetViewport_EXT);
-
-    /* skip commandBuffer */
-    /* skip firstViewport */
-    /* skip viewportCount */
-    /* skip pViewports */
-}
-
-static inline size_t vn_sizeof_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissor_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&firstScissor);
-    cmd_size += vn_sizeof_uint32_t(&scissorCount);
-    if (pScissors) {
-        cmd_size += vn_sizeof_array_size(scissorCount);
-        for (uint32_t i = 0; i < scissorCount; i++)
-            cmd_size += vn_sizeof_VkRect2D(&pScissors[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetScissor(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissor_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &firstScissor);
-    vn_encode_uint32_t(enc, &scissorCount);
-    if (pScissors) {
-        vn_encode_array_size(enc, scissorCount);
-        for (uint32_t i = 0; i < scissorCount; i++)
-            vn_encode_VkRect2D(enc, &pScissors[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdSetScissor_reply(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissor_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip firstScissor */
-    /* skip scissorCount */
-    /* skip pScissors */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetScissor_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetScissor_EXT);
-
-    /* skip commandBuffer */
-    /* skip firstScissor */
-    /* skip scissorCount */
-    /* skip pScissors */
-}
-
-static inline size_t vn_sizeof_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_float(&lineWidth);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetLineWidth(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float lineWidth)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_float(enc, &lineWidth);
-}
-
-static inline size_t vn_sizeof_vkCmdSetLineWidth_reply(VkCommandBuffer commandBuffer, float lineWidth)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip lineWidth */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetLineWidth_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, float lineWidth)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT);
-
-    /* skip commandBuffer */
-    /* skip lineWidth */
-}
-
-static inline size_t vn_sizeof_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_float(&depthBiasConstantFactor);
-    cmd_size += vn_sizeof_float(&depthBiasClamp);
-    cmd_size += vn_sizeof_float(&depthBiasSlopeFactor);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetDepthBias(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_float(enc, &depthBiasConstantFactor);
-    vn_encode_float(enc, &depthBiasClamp);
-    vn_encode_float(enc, &depthBiasSlopeFactor);
-}
-
-static inline size_t vn_sizeof_vkCmdSetDepthBias_reply(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip depthBiasConstantFactor */
-    /* skip depthBiasClamp */
-    /* skip depthBiasSlopeFactor */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetDepthBias_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT);
-
-    /* skip commandBuffer */
-    /* skip depthBiasConstantFactor */
-    /* skip depthBiasClamp */
-    /* skip depthBiasSlopeFactor */
-}
-
-static inline size_t vn_sizeof_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_array_size(4);
-    cmd_size += vn_sizeof_float_array(blendConstants, 4);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetBlendConstants(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const float blendConstants[4])
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_array_size(enc, 4);
-    vn_encode_float_array(enc, blendConstants, 4);
-}
-
-static inline size_t vn_sizeof_vkCmdSetBlendConstants_reply(VkCommandBuffer commandBuffer, const float blendConstants[4])
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip blendConstants */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetBlendConstants_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const float blendConstants[4])
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT);
-
-    /* skip commandBuffer */
-    /* skip blendConstants */
-}
-
-static inline size_t vn_sizeof_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_float(&minDepthBounds);
-    cmd_size += vn_sizeof_float(&maxDepthBounds);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetDepthBounds(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_float(enc, &minDepthBounds);
-    vn_encode_float(enc, &maxDepthBounds);
-}
-
-static inline size_t vn_sizeof_vkCmdSetDepthBounds_reply(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip minDepthBounds */
-    /* skip maxDepthBounds */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetDepthBounds_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT);
-
-    /* skip commandBuffer */
-    /* skip minDepthBounds */
-    /* skip maxDepthBounds */
-}
-
-static inline size_t vn_sizeof_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkFlags(&faceMask);
-    cmd_size += vn_sizeof_uint32_t(&compareMask);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetStencilCompareMask(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkFlags(enc, &faceMask);
-    vn_encode_uint32_t(enc, &compareMask);
-}
-
-static inline size_t vn_sizeof_vkCmdSetStencilCompareMask_reply(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip faceMask */
-    /* skip compareMask */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetStencilCompareMask_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT);
-
-    /* skip commandBuffer */
-    /* skip faceMask */
-    /* skip compareMask */
-}
-
-static inline size_t vn_sizeof_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkFlags(&faceMask);
-    cmd_size += vn_sizeof_uint32_t(&writeMask);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetStencilWriteMask(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkFlags(enc, &faceMask);
-    vn_encode_uint32_t(enc, &writeMask);
-}
-
-static inline size_t vn_sizeof_vkCmdSetStencilWriteMask_reply(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip faceMask */
-    /* skip writeMask */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetStencilWriteMask_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT);
-
-    /* skip commandBuffer */
-    /* skip faceMask */
-    /* skip writeMask */
-}
-
-static inline size_t vn_sizeof_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkFlags(&faceMask);
-    cmd_size += vn_sizeof_uint32_t(&reference);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetStencilReference(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkFlags(enc, &faceMask);
-    vn_encode_uint32_t(enc, &reference);
-}
-
-static inline size_t vn_sizeof_vkCmdSetStencilReference_reply(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip faceMask */
-    /* skip reference */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetStencilReference_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT);
-
-    /* skip commandBuffer */
-    /* skip faceMask */
-    /* skip reference */
-}
-
-static inline size_t vn_sizeof_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkPipelineBindPoint(&pipelineBindPoint);
-    cmd_size += vn_sizeof_VkPipelineLayout(&layout);
-    cmd_size += vn_sizeof_uint32_t(&firstSet);
-    cmd_size += vn_sizeof_uint32_t(&descriptorSetCount);
-    if (pDescriptorSets) {
-        cmd_size += vn_sizeof_array_size(descriptorSetCount);
-        for (uint32_t i = 0; i < descriptorSetCount; i++)
-            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_uint32_t(&dynamicOffsetCount);
-    if (pDynamicOffsets) {
-        cmd_size += vn_sizeof_array_size(dynamicOffsetCount);
-        cmd_size += vn_sizeof_uint32_t_array(pDynamicOffsets, dynamicOffsetCount);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBindDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkPipelineBindPoint(enc, &pipelineBindPoint);
-    vn_encode_VkPipelineLayout(enc, &layout);
-    vn_encode_uint32_t(enc, &firstSet);
-    vn_encode_uint32_t(enc, &descriptorSetCount);
-    if (pDescriptorSets) {
-        vn_encode_array_size(enc, descriptorSetCount);
-        for (uint32_t i = 0; i < descriptorSetCount; i++)
-            vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &dynamicOffsetCount);
-    if (pDynamicOffsets) {
-        vn_encode_array_size(enc, dynamicOffsetCount);
-        vn_encode_uint32_t_array(enc, pDynamicOffsets, dynamicOffsetCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdBindDescriptorSets_reply(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip pipelineBindPoint */
-    /* skip layout */
-    /* skip firstSet */
-    /* skip descriptorSetCount */
-    /* skip pDescriptorSets */
-    /* skip dynamicOffsetCount */
-    /* skip pDynamicOffsets */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBindDescriptorSets_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT);
-
-    /* skip commandBuffer */
-    /* skip pipelineBindPoint */
-    /* skip layout */
-    /* skip firstSet */
-    /* skip descriptorSetCount */
-    /* skip pDescriptorSets */
-    /* skip dynamicOffsetCount */
-    /* skip pDynamicOffsets */
-}
-
-static inline size_t vn_sizeof_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&buffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&offset);
-    cmd_size += vn_sizeof_VkIndexType(&indexType);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBindIndexBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkBuffer(enc, &buffer);
-    vn_encode_VkDeviceSize(enc, &offset);
-    vn_encode_VkIndexType(enc, &indexType);
-}
-
-static inline size_t vn_sizeof_vkCmdBindIndexBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-    /* skip indexType */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBindIndexBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-    /* skip indexType */
-}
-
-static inline size_t vn_sizeof_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&firstBinding);
-    cmd_size += vn_sizeof_uint32_t(&bindingCount);
-    if (pBuffers) {
-        cmd_size += vn_sizeof_array_size(bindingCount);
-        for (uint32_t i = 0; i < bindingCount; i++)
-            cmd_size += vn_sizeof_VkBuffer(&pBuffers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    if (pOffsets) {
-        cmd_size += vn_sizeof_array_size(bindingCount);
-        cmd_size += vn_sizeof_VkDeviceSize_array(pOffsets, bindingCount);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBindVertexBuffers(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &firstBinding);
-    vn_encode_uint32_t(enc, &bindingCount);
-    if (pBuffers) {
-        vn_encode_array_size(enc, bindingCount);
-        for (uint32_t i = 0; i < bindingCount; i++)
-            vn_encode_VkBuffer(enc, &pBuffers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (pOffsets) {
-        vn_encode_array_size(enc, bindingCount);
-        vn_encode_VkDeviceSize_array(enc, pOffsets, bindingCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdBindVertexBuffers_reply(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip firstBinding */
-    /* skip bindingCount */
-    /* skip pBuffers */
-    /* skip pOffsets */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBindVertexBuffers_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT);
-
-    /* skip commandBuffer */
-    /* skip firstBinding */
-    /* skip bindingCount */
-    /* skip pBuffers */
-    /* skip pOffsets */
-}
-
-static inline size_t vn_sizeof_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDraw_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&vertexCount);
-    cmd_size += vn_sizeof_uint32_t(&instanceCount);
-    cmd_size += vn_sizeof_uint32_t(&firstVertex);
-    cmd_size += vn_sizeof_uint32_t(&firstInstance);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdDraw(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDraw_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &vertexCount);
-    vn_encode_uint32_t(enc, &instanceCount);
-    vn_encode_uint32_t(enc, &firstVertex);
-    vn_encode_uint32_t(enc, &firstInstance);
-}
-
-static inline size_t vn_sizeof_vkCmdDraw_reply(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDraw_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip vertexCount */
-    /* skip instanceCount */
-    /* skip firstVertex */
-    /* skip firstInstance */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdDraw_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdDraw_EXT);
-
-    /* skip commandBuffer */
-    /* skip vertexCount */
-    /* skip instanceCount */
-    /* skip firstVertex */
-    /* skip firstInstance */
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&indexCount);
-    cmd_size += vn_sizeof_uint32_t(&instanceCount);
-    cmd_size += vn_sizeof_uint32_t(&firstIndex);
-    cmd_size += vn_sizeof_int32_t(&vertexOffset);
-    cmd_size += vn_sizeof_uint32_t(&firstInstance);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdDrawIndexed(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &indexCount);
-    vn_encode_uint32_t(enc, &instanceCount);
-    vn_encode_uint32_t(enc, &firstIndex);
-    vn_encode_int32_t(enc, &vertexOffset);
-    vn_encode_uint32_t(enc, &firstInstance);
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndexed_reply(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip indexCount */
-    /* skip instanceCount */
-    /* skip firstIndex */
-    /* skip vertexOffset */
-    /* skip firstInstance */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdDrawIndexed_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT);
-
-    /* skip commandBuffer */
-    /* skip indexCount */
-    /* skip instanceCount */
-    /* skip firstIndex */
-    /* skip vertexOffset */
-    /* skip firstInstance */
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&buffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&offset);
-    cmd_size += vn_sizeof_uint32_t(&drawCount);
-    cmd_size += vn_sizeof_uint32_t(&stride);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdDrawIndirect(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkBuffer(enc, &buffer);
-    vn_encode_VkDeviceSize(enc, &offset);
-    vn_encode_uint32_t(enc, &drawCount);
-    vn_encode_uint32_t(enc, &stride);
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndirect_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-    /* skip drawCount */
-    /* skip stride */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdDrawIndirect_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-    /* skip drawCount */
-    /* skip stride */
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&buffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&offset);
-    cmd_size += vn_sizeof_uint32_t(&drawCount);
-    cmd_size += vn_sizeof_uint32_t(&stride);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdDrawIndexedIndirect(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkBuffer(enc, &buffer);
-    vn_encode_VkDeviceSize(enc, &offset);
-    vn_encode_uint32_t(enc, &drawCount);
-    vn_encode_uint32_t(enc, &stride);
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndexedIndirect_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-    /* skip drawCount */
-    /* skip stride */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdDrawIndexedIndirect_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-    /* skip drawCount */
-    /* skip stride */
-}
-
-static inline size_t vn_sizeof_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatch_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&groupCountX);
-    cmd_size += vn_sizeof_uint32_t(&groupCountY);
-    cmd_size += vn_sizeof_uint32_t(&groupCountZ);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdDispatch(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatch_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &groupCountX);
-    vn_encode_uint32_t(enc, &groupCountY);
-    vn_encode_uint32_t(enc, &groupCountZ);
-}
-
-static inline size_t vn_sizeof_vkCmdDispatch_reply(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatch_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip groupCountX */
-    /* skip groupCountY */
-    /* skip groupCountZ */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdDispatch_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdDispatch_EXT);
-
-    /* skip commandBuffer */
-    /* skip groupCountX */
-    /* skip groupCountY */
-    /* skip groupCountZ */
-}
-
-static inline size_t vn_sizeof_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&buffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&offset);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdDispatchIndirect(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkBuffer(enc, &buffer);
-    vn_encode_VkDeviceSize(enc, &offset);
-}
-
-static inline size_t vn_sizeof_vkCmdDispatchIndirect_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdDispatchIndirect_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-}
-
-static inline size_t vn_sizeof_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&srcBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&dstBuffer);
-    cmd_size += vn_sizeof_uint32_t(&regionCount);
-    if (pRegions) {
-        cmd_size += vn_sizeof_array_size(regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            cmd_size += vn_sizeof_VkBufferCopy(&pRegions[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdCopyBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkBuffer(enc, &srcBuffer);
-    vn_encode_VkBuffer(enc, &dstBuffer);
-    vn_encode_uint32_t(enc, &regionCount);
-    if (pRegions) {
-        vn_encode_array_size(enc, regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            vn_encode_VkBufferCopy(enc, &pRegions[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdCopyBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip srcBuffer */
-    /* skip dstBuffer */
-    /* skip regionCount */
-    /* skip pRegions */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdCopyBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT);
-
-    /* skip commandBuffer */
-    /* skip srcBuffer */
-    /* skip dstBuffer */
-    /* skip regionCount */
-    /* skip pRegions */
-}
-
-static inline size_t vn_sizeof_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkImage(&srcImage);
-    cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout);
-    cmd_size += vn_sizeof_VkImage(&dstImage);
-    cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout);
-    cmd_size += vn_sizeof_uint32_t(&regionCount);
-    if (pRegions) {
-        cmd_size += vn_sizeof_array_size(regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            cmd_size += vn_sizeof_VkImageCopy(&pRegions[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdCopyImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkImage(enc, &srcImage);
-    vn_encode_VkImageLayout(enc, &srcImageLayout);
-    vn_encode_VkImage(enc, &dstImage);
-    vn_encode_VkImageLayout(enc, &dstImageLayout);
-    vn_encode_uint32_t(enc, &regionCount);
-    if (pRegions) {
-        vn_encode_array_size(enc, regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            vn_encode_VkImageCopy(enc, &pRegions[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdCopyImage_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip srcImage */
-    /* skip srcImageLayout */
-    /* skip dstImage */
-    /* skip dstImageLayout */
-    /* skip regionCount */
-    /* skip pRegions */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdCopyImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdCopyImage_EXT);
-
-    /* skip commandBuffer */
-    /* skip srcImage */
-    /* skip srcImageLayout */
-    /* skip dstImage */
-    /* skip dstImageLayout */
-    /* skip regionCount */
-    /* skip pRegions */
-}
-
-static inline size_t vn_sizeof_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkImage(&srcImage);
-    cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout);
-    cmd_size += vn_sizeof_VkImage(&dstImage);
-    cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout);
-    cmd_size += vn_sizeof_uint32_t(&regionCount);
-    if (pRegions) {
-        cmd_size += vn_sizeof_array_size(regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            cmd_size += vn_sizeof_VkImageBlit(&pRegions[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_VkFilter(&filter);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBlitImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkImage(enc, &srcImage);
-    vn_encode_VkImageLayout(enc, &srcImageLayout);
-    vn_encode_VkImage(enc, &dstImage);
-    vn_encode_VkImageLayout(enc, &dstImageLayout);
-    vn_encode_uint32_t(enc, &regionCount);
-    if (pRegions) {
-        vn_encode_array_size(enc, regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            vn_encode_VkImageBlit(enc, &pRegions[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_VkFilter(enc, &filter);
-}
-
-static inline size_t vn_sizeof_vkCmdBlitImage_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip srcImage */
-    /* skip srcImageLayout */
-    /* skip dstImage */
-    /* skip dstImageLayout */
-    /* skip regionCount */
-    /* skip pRegions */
-    /* skip filter */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBlitImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBlitImage_EXT);
-
-    /* skip commandBuffer */
-    /* skip srcImage */
-    /* skip srcImageLayout */
-    /* skip dstImage */
-    /* skip dstImageLayout */
-    /* skip regionCount */
-    /* skip pRegions */
-    /* skip filter */
-}
-
-static inline size_t vn_sizeof_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&srcBuffer);
-    cmd_size += vn_sizeof_VkImage(&dstImage);
-    cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout);
-    cmd_size += vn_sizeof_uint32_t(&regionCount);
-    if (pRegions) {
-        cmd_size += vn_sizeof_array_size(regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            cmd_size += vn_sizeof_VkBufferImageCopy(&pRegions[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdCopyBufferToImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkBuffer(enc, &srcBuffer);
-    vn_encode_VkImage(enc, &dstImage);
-    vn_encode_VkImageLayout(enc, &dstImageLayout);
-    vn_encode_uint32_t(enc, &regionCount);
-    if (pRegions) {
-        vn_encode_array_size(enc, regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            vn_encode_VkBufferImageCopy(enc, &pRegions[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdCopyBufferToImage_reply(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip srcBuffer */
-    /* skip dstImage */
-    /* skip dstImageLayout */
-    /* skip regionCount */
-    /* skip pRegions */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdCopyBufferToImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT);
-
-    /* skip commandBuffer */
-    /* skip srcBuffer */
-    /* skip dstImage */
-    /* skip dstImageLayout */
-    /* skip regionCount */
-    /* skip pRegions */
-}
-
-static inline size_t vn_sizeof_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkImage(&srcImage);
-    cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout);
-    cmd_size += vn_sizeof_VkBuffer(&dstBuffer);
-    cmd_size += vn_sizeof_uint32_t(&regionCount);
-    if (pRegions) {
-        cmd_size += vn_sizeof_array_size(regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            cmd_size += vn_sizeof_VkBufferImageCopy(&pRegions[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdCopyImageToBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkImage(enc, &srcImage);
-    vn_encode_VkImageLayout(enc, &srcImageLayout);
-    vn_encode_VkBuffer(enc, &dstBuffer);
-    vn_encode_uint32_t(enc, &regionCount);
-    if (pRegions) {
-        vn_encode_array_size(enc, regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            vn_encode_VkBufferImageCopy(enc, &pRegions[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdCopyImageToBuffer_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip srcImage */
-    /* skip srcImageLayout */
-    /* skip dstBuffer */
-    /* skip regionCount */
-    /* skip pRegions */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdCopyImageToBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT);
-
-    /* skip commandBuffer */
-    /* skip srcImage */
-    /* skip srcImageLayout */
-    /* skip dstBuffer */
-    /* skip regionCount */
-    /* skip pRegions */
-}
-
-static inline size_t vn_sizeof_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&dstBuffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&dstOffset);
-    cmd_size += vn_sizeof_VkDeviceSize(&dataSize);
-    if (pData) {
-        cmd_size += vn_sizeof_array_size(dataSize);
-        cmd_size += vn_sizeof_blob_array(pData, dataSize);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdUpdateBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkBuffer(enc, &dstBuffer);
-    vn_encode_VkDeviceSize(enc, &dstOffset);
-    vn_encode_VkDeviceSize(enc, &dataSize);
-    if (pData) {
-        vn_encode_array_size(enc, dataSize);
-        vn_encode_blob_array(enc, pData, dataSize);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdUpdateBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip dstBuffer */
-    /* skip dstOffset */
-    /* skip dataSize */
-    /* skip pData */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdUpdateBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT);
-
-    /* skip commandBuffer */
-    /* skip dstBuffer */
-    /* skip dstOffset */
-    /* skip dataSize */
-    /* skip pData */
-}
-
-static inline size_t vn_sizeof_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdFillBuffer_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&dstBuffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&dstOffset);
-    cmd_size += vn_sizeof_VkDeviceSize(&size);
-    cmd_size += vn_sizeof_uint32_t(&data);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdFillBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdFillBuffer_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkBuffer(enc, &dstBuffer);
-    vn_encode_VkDeviceSize(enc, &dstOffset);
-    vn_encode_VkDeviceSize(enc, &size);
-    vn_encode_uint32_t(enc, &data);
-}
-
-static inline size_t vn_sizeof_vkCmdFillBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdFillBuffer_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip dstBuffer */
-    /* skip dstOffset */
-    /* skip size */
-    /* skip data */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdFillBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdFillBuffer_EXT);
-
-    /* skip commandBuffer */
-    /* skip dstBuffer */
-    /* skip dstOffset */
-    /* skip size */
-    /* skip data */
-}
-
-static inline size_t vn_sizeof_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearColorImage_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkImage(&image);
-    cmd_size += vn_sizeof_VkImageLayout(&imageLayout);
-    cmd_size += vn_sizeof_simple_pointer(pColor);
-    if (pColor)
-        cmd_size += vn_sizeof_VkClearColorValue(pColor);
-    cmd_size += vn_sizeof_uint32_t(&rangeCount);
-    if (pRanges) {
-        cmd_size += vn_sizeof_array_size(rangeCount);
-        for (uint32_t i = 0; i < rangeCount; i++)
-            cmd_size += vn_sizeof_VkImageSubresourceRange(&pRanges[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdClearColorImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearColorImage_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkImage(enc, &image);
-    vn_encode_VkImageLayout(enc, &imageLayout);
-    if (vn_encode_simple_pointer(enc, pColor))
-        vn_encode_VkClearColorValue(enc, pColor);
-    vn_encode_uint32_t(enc, &rangeCount);
-    if (pRanges) {
-        vn_encode_array_size(enc, rangeCount);
-        for (uint32_t i = 0; i < rangeCount; i++)
-            vn_encode_VkImageSubresourceRange(enc, &pRanges[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdClearColorImage_reply(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearColorImage_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip image */
-    /* skip imageLayout */
-    /* skip pColor */
-    /* skip rangeCount */
-    /* skip pRanges */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdClearColorImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdClearColorImage_EXT);
-
-    /* skip commandBuffer */
-    /* skip image */
-    /* skip imageLayout */
-    /* skip pColor */
-    /* skip rangeCount */
-    /* skip pRanges */
-}
-
-static inline size_t vn_sizeof_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkImage(&image);
-    cmd_size += vn_sizeof_VkImageLayout(&imageLayout);
-    cmd_size += vn_sizeof_simple_pointer(pDepthStencil);
-    if (pDepthStencil)
-        cmd_size += vn_sizeof_VkClearDepthStencilValue(pDepthStencil);
-    cmd_size += vn_sizeof_uint32_t(&rangeCount);
-    if (pRanges) {
-        cmd_size += vn_sizeof_array_size(rangeCount);
-        for (uint32_t i = 0; i < rangeCount; i++)
-            cmd_size += vn_sizeof_VkImageSubresourceRange(&pRanges[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdClearDepthStencilImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkImage(enc, &image);
-    vn_encode_VkImageLayout(enc, &imageLayout);
-    if (vn_encode_simple_pointer(enc, pDepthStencil))
-        vn_encode_VkClearDepthStencilValue(enc, pDepthStencil);
-    vn_encode_uint32_t(enc, &rangeCount);
-    if (pRanges) {
-        vn_encode_array_size(enc, rangeCount);
-        for (uint32_t i = 0; i < rangeCount; i++)
-            vn_encode_VkImageSubresourceRange(enc, &pRanges[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdClearDepthStencilImage_reply(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip image */
-    /* skip imageLayout */
-    /* skip pDepthStencil */
-    /* skip rangeCount */
-    /* skip pRanges */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdClearDepthStencilImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT);
-
-    /* skip commandBuffer */
-    /* skip image */
-    /* skip imageLayout */
-    /* skip pDepthStencil */
-    /* skip rangeCount */
-    /* skip pRanges */
-}
-
-static inline size_t vn_sizeof_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearAttachments_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&attachmentCount);
-    if (pAttachments) {
-        cmd_size += vn_sizeof_array_size(attachmentCount);
-        for (uint32_t i = 0; i < attachmentCount; i++)
-            cmd_size += vn_sizeof_VkClearAttachment(&pAttachments[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_uint32_t(&rectCount);
-    if (pRects) {
-        cmd_size += vn_sizeof_array_size(rectCount);
-        for (uint32_t i = 0; i < rectCount; i++)
-            cmd_size += vn_sizeof_VkClearRect(&pRects[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdClearAttachments(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearAttachments_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &attachmentCount);
-    if (pAttachments) {
-        vn_encode_array_size(enc, attachmentCount);
-        for (uint32_t i = 0; i < attachmentCount; i++)
-            vn_encode_VkClearAttachment(enc, &pAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &rectCount);
-    if (pRects) {
-        vn_encode_array_size(enc, rectCount);
-        for (uint32_t i = 0; i < rectCount; i++)
-            vn_encode_VkClearRect(enc, &pRects[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdClearAttachments_reply(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearAttachments_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip attachmentCount */
-    /* skip pAttachments */
-    /* skip rectCount */
-    /* skip pRects */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdClearAttachments_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdClearAttachments_EXT);
-
-    /* skip commandBuffer */
-    /* skip attachmentCount */
-    /* skip pAttachments */
-    /* skip rectCount */
-    /* skip pRects */
-}
-
-static inline size_t vn_sizeof_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkImage(&srcImage);
-    cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout);
-    cmd_size += vn_sizeof_VkImage(&dstImage);
-    cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout);
-    cmd_size += vn_sizeof_uint32_t(&regionCount);
-    if (pRegions) {
-        cmd_size += vn_sizeof_array_size(regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            cmd_size += vn_sizeof_VkImageResolve(&pRegions[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdResolveImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkImage(enc, &srcImage);
-    vn_encode_VkImageLayout(enc, &srcImageLayout);
-    vn_encode_VkImage(enc, &dstImage);
-    vn_encode_VkImageLayout(enc, &dstImageLayout);
-    vn_encode_uint32_t(enc, &regionCount);
-    if (pRegions) {
-        vn_encode_array_size(enc, regionCount);
-        for (uint32_t i = 0; i < regionCount; i++)
-            vn_encode_VkImageResolve(enc, &pRegions[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdResolveImage_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip srcImage */
-    /* skip srcImageLayout */
-    /* skip dstImage */
-    /* skip dstImageLayout */
-    /* skip regionCount */
-    /* skip pRegions */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdResolveImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdResolveImage_EXT);
-
-    /* skip commandBuffer */
-    /* skip srcImage */
-    /* skip srcImageLayout */
-    /* skip dstImage */
-    /* skip dstImageLayout */
-    /* skip regionCount */
-    /* skip pRegions */
-}
-
-static inline size_t vn_sizeof_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkEvent(&event);
-    cmd_size += vn_sizeof_VkFlags(&stageMask);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkEvent(enc, &event);
-    vn_encode_VkFlags(enc, &stageMask);
-}
-
-static inline size_t vn_sizeof_vkCmdSetEvent_reply(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip event */
-    /* skip stageMask */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetEvent_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetEvent_EXT);
-
-    /* skip commandBuffer */
-    /* skip event */
-    /* skip stageMask */
-}
-
-static inline size_t vn_sizeof_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkEvent(&event);
-    cmd_size += vn_sizeof_VkFlags(&stageMask);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdResetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkEvent(enc, &event);
-    vn_encode_VkFlags(enc, &stageMask);
-}
-
-static inline size_t vn_sizeof_vkCmdResetEvent_reply(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip event */
-    /* skip stageMask */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdResetEvent_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdResetEvent_EXT);
-
-    /* skip commandBuffer */
-    /* skip event */
-    /* skip stageMask */
-}
-
-static inline size_t vn_sizeof_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&eventCount);
-    if (pEvents) {
-        cmd_size += vn_sizeof_array_size(eventCount);
-        for (uint32_t i = 0; i < eventCount; i++)
-            cmd_size += vn_sizeof_VkEvent(&pEvents[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_VkFlags(&srcStageMask);
-    cmd_size += vn_sizeof_VkFlags(&dstStageMask);
-    cmd_size += vn_sizeof_uint32_t(&memoryBarrierCount);
-    if (pMemoryBarriers) {
-        cmd_size += vn_sizeof_array_size(memoryBarrierCount);
-        for (uint32_t i = 0; i < memoryBarrierCount; i++)
-            cmd_size += vn_sizeof_VkMemoryBarrier(&pMemoryBarriers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_uint32_t(&bufferMemoryBarrierCount);
-    if (pBufferMemoryBarriers) {
-        cmd_size += vn_sizeof_array_size(bufferMemoryBarrierCount);
-        for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++)
-            cmd_size += vn_sizeof_VkBufferMemoryBarrier(&pBufferMemoryBarriers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_uint32_t(&imageMemoryBarrierCount);
-    if (pImageMemoryBarriers) {
-        cmd_size += vn_sizeof_array_size(imageMemoryBarrierCount);
-        for (uint32_t i = 0; i < imageMemoryBarrierCount; i++)
-            cmd_size += vn_sizeof_VkImageMemoryBarrier(&pImageMemoryBarriers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdWaitEvents(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &eventCount);
-    if (pEvents) {
-        vn_encode_array_size(enc, eventCount);
-        for (uint32_t i = 0; i < eventCount; i++)
-            vn_encode_VkEvent(enc, &pEvents[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_VkFlags(enc, &srcStageMask);
-    vn_encode_VkFlags(enc, &dstStageMask);
-    vn_encode_uint32_t(enc, &memoryBarrierCount);
-    if (pMemoryBarriers) {
-        vn_encode_array_size(enc, memoryBarrierCount);
-        for (uint32_t i = 0; i < memoryBarrierCount; i++)
-            vn_encode_VkMemoryBarrier(enc, &pMemoryBarriers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &bufferMemoryBarrierCount);
-    if (pBufferMemoryBarriers) {
-        vn_encode_array_size(enc, bufferMemoryBarrierCount);
-        for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++)
-            vn_encode_VkBufferMemoryBarrier(enc, &pBufferMemoryBarriers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &imageMemoryBarrierCount);
-    if (pImageMemoryBarriers) {
-        vn_encode_array_size(enc, imageMemoryBarrierCount);
-        for (uint32_t i = 0; i < imageMemoryBarrierCount; i++)
-            vn_encode_VkImageMemoryBarrier(enc, &pImageMemoryBarriers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdWaitEvents_reply(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip eventCount */
-    /* skip pEvents */
-    /* skip srcStageMask */
-    /* skip dstStageMask */
-    /* skip memoryBarrierCount */
-    /* skip pMemoryBarriers */
-    /* skip bufferMemoryBarrierCount */
-    /* skip pBufferMemoryBarriers */
-    /* skip imageMemoryBarrierCount */
-    /* skip pImageMemoryBarriers */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdWaitEvents_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdWaitEvents_EXT);
-
-    /* skip commandBuffer */
-    /* skip eventCount */
-    /* skip pEvents */
-    /* skip srcStageMask */
-    /* skip dstStageMask */
-    /* skip memoryBarrierCount */
-    /* skip pMemoryBarriers */
-    /* skip bufferMemoryBarrierCount */
-    /* skip pBufferMemoryBarriers */
-    /* skip imageMemoryBarrierCount */
-    /* skip pImageMemoryBarriers */
-}
-
-static inline size_t vn_sizeof_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkFlags(&srcStageMask);
-    cmd_size += vn_sizeof_VkFlags(&dstStageMask);
-    cmd_size += vn_sizeof_VkFlags(&dependencyFlags);
-    cmd_size += vn_sizeof_uint32_t(&memoryBarrierCount);
-    if (pMemoryBarriers) {
-        cmd_size += vn_sizeof_array_size(memoryBarrierCount);
-        for (uint32_t i = 0; i < memoryBarrierCount; i++)
-            cmd_size += vn_sizeof_VkMemoryBarrier(&pMemoryBarriers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_uint32_t(&bufferMemoryBarrierCount);
-    if (pBufferMemoryBarriers) {
-        cmd_size += vn_sizeof_array_size(bufferMemoryBarrierCount);
-        for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++)
-            cmd_size += vn_sizeof_VkBufferMemoryBarrier(&pBufferMemoryBarriers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_uint32_t(&imageMemoryBarrierCount);
-    if (pImageMemoryBarriers) {
-        cmd_size += vn_sizeof_array_size(imageMemoryBarrierCount);
-        for (uint32_t i = 0; i < imageMemoryBarrierCount; i++)
-            cmd_size += vn_sizeof_VkImageMemoryBarrier(&pImageMemoryBarriers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdPipelineBarrier(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkFlags(enc, &srcStageMask);
-    vn_encode_VkFlags(enc, &dstStageMask);
-    vn_encode_VkFlags(enc, &dependencyFlags);
-    vn_encode_uint32_t(enc, &memoryBarrierCount);
-    if (pMemoryBarriers) {
-        vn_encode_array_size(enc, memoryBarrierCount);
-        for (uint32_t i = 0; i < memoryBarrierCount; i++)
-            vn_encode_VkMemoryBarrier(enc, &pMemoryBarriers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &bufferMemoryBarrierCount);
-    if (pBufferMemoryBarriers) {
-        vn_encode_array_size(enc, bufferMemoryBarrierCount);
-        for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++)
-            vn_encode_VkBufferMemoryBarrier(enc, &pBufferMemoryBarriers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &imageMemoryBarrierCount);
-    if (pImageMemoryBarriers) {
-        vn_encode_array_size(enc, imageMemoryBarrierCount);
-        for (uint32_t i = 0; i < imageMemoryBarrierCount; i++)
-            vn_encode_VkImageMemoryBarrier(enc, &pImageMemoryBarriers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdPipelineBarrier_reply(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip srcStageMask */
-    /* skip dstStageMask */
-    /* skip dependencyFlags */
-    /* skip memoryBarrierCount */
-    /* skip pMemoryBarriers */
-    /* skip bufferMemoryBarrierCount */
-    /* skip pBufferMemoryBarriers */
-    /* skip imageMemoryBarrierCount */
-    /* skip pImageMemoryBarriers */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdPipelineBarrier_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT);
-
-    /* skip commandBuffer */
-    /* skip srcStageMask */
-    /* skip dstStageMask */
-    /* skip dependencyFlags */
-    /* skip memoryBarrierCount */
-    /* skip pMemoryBarriers */
-    /* skip bufferMemoryBarrierCount */
-    /* skip pBufferMemoryBarriers */
-    /* skip imageMemoryBarrierCount */
-    /* skip pImageMemoryBarriers */
-}
-
-static inline size_t vn_sizeof_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQuery_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
-    cmd_size += vn_sizeof_uint32_t(&query);
-    cmd_size += vn_sizeof_VkFlags(&flags);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBeginQuery(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQuery_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkQueryPool(enc, &queryPool);
-    vn_encode_uint32_t(enc, &query);
-    vn_encode_VkFlags(enc, &flags);
-}
-
-static inline size_t vn_sizeof_vkCmdBeginQuery_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQuery_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip query */
-    /* skip flags */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBeginQuery_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBeginQuery_EXT);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip query */
-    /* skip flags */
-}
-
-static inline size_t vn_sizeof_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQuery_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
-    cmd_size += vn_sizeof_uint32_t(&query);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdEndQuery(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQuery_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkQueryPool(enc, &queryPool);
-    vn_encode_uint32_t(enc, &query);
-}
-
-static inline size_t vn_sizeof_vkCmdEndQuery_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQuery_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip query */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdEndQuery_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdEndQuery_EXT);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip query */
-}
-
-static inline size_t vn_sizeof_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
-    cmd_size += vn_sizeof_uint32_t(&firstQuery);
-    cmd_size += vn_sizeof_uint32_t(&queryCount);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdResetQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkQueryPool(enc, &queryPool);
-    vn_encode_uint32_t(enc, &firstQuery);
-    vn_encode_uint32_t(enc, &queryCount);
-}
-
-static inline size_t vn_sizeof_vkCmdResetQueryPool_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip firstQuery */
-    /* skip queryCount */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdResetQueryPool_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip firstQuery */
-    /* skip queryCount */
-}
-
-static inline size_t vn_sizeof_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkPipelineStageFlagBits(&pipelineStage);
-    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
-    cmd_size += vn_sizeof_uint32_t(&query);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdWriteTimestamp(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkPipelineStageFlagBits(enc, &pipelineStage);
-    vn_encode_VkQueryPool(enc, &queryPool);
-    vn_encode_uint32_t(enc, &query);
-}
-
-static inline size_t vn_sizeof_vkCmdWriteTimestamp_reply(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip pipelineStage */
-    /* skip queryPool */
-    /* skip query */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdWriteTimestamp_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT);
-
-    /* skip commandBuffer */
-    /* skip pipelineStage */
-    /* skip queryPool */
-    /* skip query */
-}
-
-static inline size_t vn_sizeof_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
-    cmd_size += vn_sizeof_uint32_t(&firstQuery);
-    cmd_size += vn_sizeof_uint32_t(&queryCount);
-    cmd_size += vn_sizeof_VkBuffer(&dstBuffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&dstOffset);
-    cmd_size += vn_sizeof_VkDeviceSize(&stride);
-    cmd_size += vn_sizeof_VkFlags(&flags);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdCopyQueryPoolResults(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkQueryPool(enc, &queryPool);
-    vn_encode_uint32_t(enc, &firstQuery);
-    vn_encode_uint32_t(enc, &queryCount);
-    vn_encode_VkBuffer(enc, &dstBuffer);
-    vn_encode_VkDeviceSize(enc, &dstOffset);
-    vn_encode_VkDeviceSize(enc, &stride);
-    vn_encode_VkFlags(enc, &flags);
-}
-
-static inline size_t vn_sizeof_vkCmdCopyQueryPoolResults_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip firstQuery */
-    /* skip queryCount */
-    /* skip dstBuffer */
-    /* skip dstOffset */
-    /* skip stride */
-    /* skip flags */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdCopyQueryPoolResults_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip firstQuery */
-    /* skip queryCount */
-    /* skip dstBuffer */
-    /* skip dstOffset */
-    /* skip stride */
-    /* skip flags */
-}
-
-static inline size_t vn_sizeof_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPushConstants_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkPipelineLayout(&layout);
-    cmd_size += vn_sizeof_VkFlags(&stageFlags);
-    cmd_size += vn_sizeof_uint32_t(&offset);
-    cmd_size += vn_sizeof_uint32_t(&size);
-    if (pValues) {
-        cmd_size += vn_sizeof_array_size(size);
-        cmd_size += vn_sizeof_blob_array(pValues, size);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdPushConstants(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPushConstants_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkPipelineLayout(enc, &layout);
-    vn_encode_VkFlags(enc, &stageFlags);
-    vn_encode_uint32_t(enc, &offset);
-    vn_encode_uint32_t(enc, &size);
-    if (pValues) {
-        vn_encode_array_size(enc, size);
-        vn_encode_blob_array(enc, pValues, size);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdPushConstants_reply(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPushConstants_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip layout */
-    /* skip stageFlags */
-    /* skip offset */
-    /* skip size */
-    /* skip pValues */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdPushConstants_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdPushConstants_EXT);
-
-    /* skip commandBuffer */
-    /* skip layout */
-    /* skip stageFlags */
-    /* skip offset */
-    /* skip size */
-    /* skip pValues */
-}
-
-static inline size_t vn_sizeof_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_simple_pointer(pRenderPassBegin);
-    if (pRenderPassBegin)
-        cmd_size += vn_sizeof_VkRenderPassBeginInfo(pRenderPassBegin);
-    cmd_size += vn_sizeof_VkSubpassContents(&contents);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBeginRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    if (vn_encode_simple_pointer(enc, pRenderPassBegin))
-        vn_encode_VkRenderPassBeginInfo(enc, pRenderPassBegin);
-    vn_encode_VkSubpassContents(enc, &contents);
-}
-
-static inline size_t vn_sizeof_vkCmdBeginRenderPass_reply(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip pRenderPassBegin */
-    /* skip contents */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBeginRenderPass_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT);
-
-    /* skip commandBuffer */
-    /* skip pRenderPassBegin */
-    /* skip contents */
-}
-
-static inline size_t vn_sizeof_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkSubpassContents(&contents);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdNextSubpass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkSubpassContents contents)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkSubpassContents(enc, &contents);
-}
-
-static inline size_t vn_sizeof_vkCmdNextSubpass_reply(VkCommandBuffer commandBuffer, VkSubpassContents contents)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip contents */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdNextSubpass_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkSubpassContents contents)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdNextSubpass_EXT);
-
-    /* skip commandBuffer */
-    /* skip contents */
-}
-
-static inline size_t vn_sizeof_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdEndRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-}
-
-static inline size_t vn_sizeof_vkCmdEndRenderPass_reply(VkCommandBuffer commandBuffer)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdEndRenderPass_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT);
-
-    /* skip commandBuffer */
-}
-
-static inline size_t vn_sizeof_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&commandBufferCount);
-    if (pCommandBuffers) {
-        cmd_size += vn_sizeof_array_size(commandBufferCount);
-        for (uint32_t i = 0; i < commandBufferCount; i++)
-            cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdExecuteCommands(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &commandBufferCount);
-    if (pCommandBuffers) {
-        vn_encode_array_size(enc, commandBufferCount);
-        for (uint32_t i = 0; i < commandBufferCount; i++)
-            vn_encode_VkCommandBuffer(enc, &pCommandBuffers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdExecuteCommands_reply(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip commandBufferCount */
-    /* skip pCommandBuffers */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdExecuteCommands_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT);
-
-    /* skip commandBuffer */
-    /* skip commandBufferCount */
-    /* skip pCommandBuffers */
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pFeatures);
-    if (pFeatures)
-        cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2_partial(pFeatures);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pFeatures))
-        vn_encode_VkPhysicalDeviceFeatures2_partial(enc, pFeatures);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    cmd_size += vn_sizeof_simple_pointer(pFeatures);
-    if (pFeatures)
-        cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2(pFeatures);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT);
-
-    /* skip physicalDevice */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkPhysicalDeviceFeatures2(dec, pFeatures);
-    } else {
-        pFeatures = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pProperties);
-    if (pProperties)
-        cmd_size += vn_sizeof_VkPhysicalDeviceProperties2_partial(pProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pProperties))
-        vn_encode_VkPhysicalDeviceProperties2_partial(enc, pProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    cmd_size += vn_sizeof_simple_pointer(pProperties);
-    if (pProperties)
-        cmd_size += vn_sizeof_VkPhysicalDeviceProperties2(pProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT);
-
-    /* skip physicalDevice */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkPhysicalDeviceProperties2(dec, pProperties);
-    } else {
-        pProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_VkFormat(&format);
-    cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
-    if (pFormatProperties)
-        cmd_size += vn_sizeof_VkFormatProperties2_partial(pFormatProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    vn_encode_VkFormat(enc, &format);
-    if (vn_encode_simple_pointer(enc, pFormatProperties))
-        vn_encode_VkFormatProperties2_partial(enc, pFormatProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    /* skip format */
-    cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
-    if (pFormatProperties)
-        cmd_size += vn_sizeof_VkFormatProperties2(pFormatProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT);
-
-    /* skip physicalDevice */
-    /* skip format */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkFormatProperties2(dec, pFormatProperties);
-    } else {
-        pFormatProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pImageFormatInfo);
-    if (pImageFormatInfo)
-        cmd_size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2(pImageFormatInfo);
-    cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
-    if (pImageFormatProperties)
-        cmd_size += vn_sizeof_VkImageFormatProperties2_partial(pImageFormatProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pImageFormatInfo))
-        vn_encode_VkPhysicalDeviceImageFormatInfo2(enc, pImageFormatInfo);
-    if (vn_encode_simple_pointer(enc, pImageFormatProperties))
-        vn_encode_VkImageFormatProperties2_partial(enc, pImageFormatProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip physicalDevice */
-    /* skip pImageFormatInfo */
-    cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
-    if (pImageFormatProperties)
-        cmd_size += vn_sizeof_VkImageFormatProperties2(pImageFormatProperties);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip physicalDevice */
-    /* skip pImageFormatInfo */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkImageFormatProperties2(dec, pImageFormatProperties);
-    } else {
-        pImageFormatProperties = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
-    if (pQueueFamilyPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
-    if (pQueueFamilyProperties) {
-        cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount);
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
-            cmd_size += vn_sizeof_VkQueueFamilyProperties2_partial(&pQueueFamilyProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
-        vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
-    if (pQueueFamilyProperties) {
-        vn_encode_array_size(enc, *pQueueFamilyPropertyCount);
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
-            vn_encode_VkQueueFamilyProperties2_partial(enc, &pQueueFamilyProperties[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
-    if (pQueueFamilyPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
-    if (pQueueFamilyProperties) {
-        cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount);
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
-            cmd_size += vn_sizeof_VkQueueFamilyProperties2(&pQueueFamilyProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT);
-
-    /* skip physicalDevice */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
-    } else {
-        pQueueFamilyPropertyCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pQueueFamilyPropertyCount);
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
-            vn_decode_VkQueueFamilyProperties2(dec, &pQueueFamilyProperties[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pQueueFamilyProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
-    if (pMemoryProperties)
-        cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(pMemoryProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pMemoryProperties))
-        vn_encode_VkPhysicalDeviceMemoryProperties2_partial(enc, pMemoryProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
-    if (pMemoryProperties)
-        cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2(pMemoryProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT);
-
-    /* skip physicalDevice */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkPhysicalDeviceMemoryProperties2(dec, pMemoryProperties);
-    } else {
-        pMemoryProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pFormatInfo);
-    if (pFormatInfo)
-        cmd_size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(pFormatInfo);
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkSparseImageFormatProperties2_partial(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pFormatInfo))
-        vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(enc, pFormatInfo);
-    if (vn_encode_simple_pointer(enc, pPropertyCount))
-        vn_encode_uint32_t(enc, pPropertyCount);
-    if (pProperties) {
-        vn_encode_array_size(enc, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_encode_VkSparseImageFormatProperties2_partial(enc, &pProperties[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    /* skip pFormatInfo */
-    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
-    if (pPropertyCount)
-        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
-    if (pProperties) {
-        cmd_size += vn_sizeof_array_size(*pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            cmd_size += vn_sizeof_VkSparseImageFormatProperties2(&pProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT);
-
-    /* skip physicalDevice */
-    /* skip pFormatInfo */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pPropertyCount);
-    } else {
-        pPropertyCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pPropertyCount);
-        for (uint32_t i = 0; i < *pPropertyCount; i++)
-            vn_decode_VkSparseImageFormatProperties2(dec, &pProperties[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
-    cmd_size += vn_sizeof_VkFlags(&flags);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkTrimCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkCommandPool(enc, &commandPool);
-    vn_encode_VkFlags(enc, &flags);
-}
-
-static inline size_t vn_sizeof_vkTrimCommandPool_reply(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip commandPool */
-    /* skip flags */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkTrimCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkTrimCommandPool_EXT);
-
-    /* skip device */
-    /* skip commandPool */
-    /* skip flags */
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pExternalBufferInfo);
-    if (pExternalBufferInfo)
-        cmd_size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo(pExternalBufferInfo);
-    cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
-    if (pExternalBufferProperties)
-        cmd_size += vn_sizeof_VkExternalBufferProperties_partial(pExternalBufferProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pExternalBufferInfo))
-        vn_encode_VkPhysicalDeviceExternalBufferInfo(enc, pExternalBufferInfo);
-    if (vn_encode_simple_pointer(enc, pExternalBufferProperties))
-        vn_encode_VkExternalBufferProperties_partial(enc, pExternalBufferProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    /* skip pExternalBufferInfo */
-    cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
-    if (pExternalBufferProperties)
-        cmd_size += vn_sizeof_VkExternalBufferProperties(pExternalBufferProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT);
-
-    /* skip physicalDevice */
-    /* skip pExternalBufferInfo */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkExternalBufferProperties(dec, pExternalBufferProperties);
-    } else {
-        pExternalBufferProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreInfo);
-    if (pExternalSemaphoreInfo)
-        cmd_size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(pExternalSemaphoreInfo);
-    cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
-    if (pExternalSemaphoreProperties)
-        cmd_size += vn_sizeof_VkExternalSemaphoreProperties_partial(pExternalSemaphoreProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pExternalSemaphoreInfo))
-        vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(enc, pExternalSemaphoreInfo);
-    if (vn_encode_simple_pointer(enc, pExternalSemaphoreProperties))
-        vn_encode_VkExternalSemaphoreProperties_partial(enc, pExternalSemaphoreProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    /* skip pExternalSemaphoreInfo */
-    cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
-    if (pExternalSemaphoreProperties)
-        cmd_size += vn_sizeof_VkExternalSemaphoreProperties(pExternalSemaphoreProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT);
-
-    /* skip physicalDevice */
-    /* skip pExternalSemaphoreInfo */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkExternalSemaphoreProperties(dec, pExternalSemaphoreProperties);
-    } else {
-        pExternalSemaphoreProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
-    cmd_size += vn_sizeof_simple_pointer(pExternalFenceInfo);
-    if (pExternalFenceInfo)
-        cmd_size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo(pExternalFenceInfo);
-    cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
-    if (pExternalFenceProperties)
-        cmd_size += vn_sizeof_VkExternalFenceProperties_partial(pExternalFenceProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
-    if (vn_encode_simple_pointer(enc, pExternalFenceInfo))
-        vn_encode_VkPhysicalDeviceExternalFenceInfo(enc, pExternalFenceInfo);
-    if (vn_encode_simple_pointer(enc, pExternalFenceProperties))
-        vn_encode_VkExternalFenceProperties_partial(enc, pExternalFenceProperties);
-}
-
-static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip physicalDevice */
-    /* skip pExternalFenceInfo */
-    cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
-    if (pExternalFenceProperties)
-        cmd_size += vn_sizeof_VkExternalFenceProperties(pExternalFenceProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT);
-
-    /* skip physicalDevice */
-    /* skip pExternalFenceInfo */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkExternalFenceProperties(dec, pExternalFenceProperties);
-    } else {
-        pExternalFenceProperties = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkInstance(&instance);
-    cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
-    if (pPhysicalDeviceGroupCount)
-        cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
-    if (pPhysicalDeviceGroupProperties) {
-        cmd_size += vn_sizeof_array_size(*pPhysicalDeviceGroupCount);
-        for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++)
-            cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties_partial(&pPhysicalDeviceGroupProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkInstance(enc, &instance);
-    if (vn_encode_simple_pointer(enc, pPhysicalDeviceGroupCount))
-        vn_encode_uint32_t(enc, pPhysicalDeviceGroupCount);
-    if (pPhysicalDeviceGroupProperties) {
-        vn_encode_array_size(enc, *pPhysicalDeviceGroupCount);
-        for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++)
-            vn_encode_VkPhysicalDeviceGroupProperties_partial(enc, &pPhysicalDeviceGroupProperties[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip instance */
-    cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
-    if (pPhysicalDeviceGroupCount)
-        cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
-    if (pPhysicalDeviceGroupProperties) {
-        cmd_size += vn_sizeof_array_size(*pPhysicalDeviceGroupCount);
-        for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++)
-            cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties(&pPhysicalDeviceGroupProperties[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip instance */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pPhysicalDeviceGroupCount);
-    } else {
-        pPhysicalDeviceGroupCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pPhysicalDeviceGroupCount);
-        for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++)
-            vn_decode_VkPhysicalDeviceGroupProperties(dec, &pPhysicalDeviceGroupProperties[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pPhysicalDeviceGroupProperties = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_uint32_t(&heapIndex);
-    cmd_size += vn_sizeof_uint32_t(&localDeviceIndex);
-    cmd_size += vn_sizeof_uint32_t(&remoteDeviceIndex);
-    cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures); /* out */
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetDeviceGroupPeerMemoryFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_uint32_t(enc, &heapIndex);
-    vn_encode_uint32_t(enc, &localDeviceIndex);
-    vn_encode_uint32_t(enc, &remoteDeviceIndex);
-    vn_encode_simple_pointer(enc, pPeerMemoryFeatures); /* out */
-}
-
-static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip heapIndex */
-    /* skip localDeviceIndex */
-    /* skip remoteDeviceIndex */
-    cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures);
-    if (pPeerMemoryFeatures)
-        cmd_size += vn_sizeof_VkFlags(pPeerMemoryFeatures);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT);
-
-    /* skip device */
-    /* skip heapIndex */
-    /* skip localDeviceIndex */
-    /* skip remoteDeviceIndex */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkFlags(dec, pPeerMemoryFeatures);
-    } else {
-        pPeerMemoryFeatures = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_uint32_t(&bindInfoCount);
-    if (pBindInfos) {
-        cmd_size += vn_sizeof_array_size(bindInfoCount);
-        for (uint32_t i = 0; i < bindInfoCount; i++)
-            cmd_size += vn_sizeof_VkBindBufferMemoryInfo(&pBindInfos[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkBindBufferMemory2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_uint32_t(enc, &bindInfoCount);
-    if (pBindInfos) {
-        vn_encode_array_size(enc, bindInfoCount);
-        for (uint32_t i = 0; i < bindInfoCount; i++)
-            vn_encode_VkBindBufferMemoryInfo(enc, &pBindInfos[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkBindBufferMemory2_reply(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip bindInfoCount */
-    /* skip pBindInfos */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkBindBufferMemory2_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkBindBufferMemory2_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip bindInfoCount */
-    /* skip pBindInfos */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_uint32_t(&bindInfoCount);
-    if (pBindInfos) {
-        cmd_size += vn_sizeof_array_size(bindInfoCount);
-        for (uint32_t i = 0; i < bindInfoCount; i++)
-            cmd_size += vn_sizeof_VkBindImageMemoryInfo(&pBindInfos[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkBindImageMemory2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_uint32_t(enc, &bindInfoCount);
-    if (pBindInfos) {
-        vn_encode_array_size(enc, bindInfoCount);
-        for (uint32_t i = 0; i < bindInfoCount; i++)
-            vn_encode_VkBindImageMemoryInfo(enc, &pBindInfos[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkBindImageMemory2_reply(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip bindInfoCount */
-    /* skip pBindInfos */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkBindImageMemory2_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory2_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip bindInfoCount */
-    /* skip pBindInfos */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&deviceMask);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdSetDeviceMask(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t deviceMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &deviceMask);
-}
-
-static inline size_t vn_sizeof_vkCmdSetDeviceMask_reply(VkCommandBuffer commandBuffer, uint32_t deviceMask)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip deviceMask */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdSetDeviceMask_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t deviceMask)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT);
-
-    /* skip commandBuffer */
-    /* skip deviceMask */
-}
-
-static inline size_t vn_sizeof_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchBase_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&baseGroupX);
-    cmd_size += vn_sizeof_uint32_t(&baseGroupY);
-    cmd_size += vn_sizeof_uint32_t(&baseGroupZ);
-    cmd_size += vn_sizeof_uint32_t(&groupCountX);
-    cmd_size += vn_sizeof_uint32_t(&groupCountY);
-    cmd_size += vn_sizeof_uint32_t(&groupCountZ);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdDispatchBase(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchBase_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &baseGroupX);
-    vn_encode_uint32_t(enc, &baseGroupY);
-    vn_encode_uint32_t(enc, &baseGroupZ);
-    vn_encode_uint32_t(enc, &groupCountX);
-    vn_encode_uint32_t(enc, &groupCountY);
-    vn_encode_uint32_t(enc, &groupCountZ);
-}
-
-static inline size_t vn_sizeof_vkCmdDispatchBase_reply(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchBase_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip baseGroupX */
-    /* skip baseGroupY */
-    /* skip baseGroupZ */
-    /* skip groupCountX */
-    /* skip groupCountY */
-    /* skip groupCountZ */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdDispatchBase_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdDispatchBase_EXT);
-
-    /* skip commandBuffer */
-    /* skip baseGroupX */
-    /* skip baseGroupY */
-    /* skip baseGroupZ */
-    /* skip groupCountX */
-    /* skip groupCountY */
-    /* skip groupCountZ */
-}
-
-static inline size_t vn_sizeof_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pDescriptorUpdateTemplate);
-    if (pDescriptorUpdateTemplate)
-        cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(pDescriptorUpdateTemplate);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateDescriptorUpdateTemplate(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkDescriptorUpdateTemplateCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pDescriptorUpdateTemplate))
-        vn_encode_VkDescriptorUpdateTemplate(enc, pDescriptorUpdateTemplate);
-}
-
-static inline size_t vn_sizeof_vkCreateDescriptorUpdateTemplate_reply(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pDescriptorUpdateTemplate);
-    if (pDescriptorUpdateTemplate)
-        cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(pDescriptorUpdateTemplate);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateDescriptorUpdateTemplate_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkDescriptorUpdateTemplate(dec, pDescriptorUpdateTemplate);
-    } else {
-        pDescriptorUpdateTemplate = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(&descriptorUpdateTemplate);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyDescriptorUpdateTemplate(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkDescriptorUpdateTemplate(enc, &descriptorUpdateTemplate);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroyDescriptorUpdateTemplate_reply(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip descriptorUpdateTemplate */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyDescriptorUpdateTemplate_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT);
-
-    /* skip device */
-    /* skip descriptorUpdateTemplate */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pInfo);
-    if (pInfo)
-        cmd_size += vn_sizeof_VkBufferMemoryRequirementsInfo2(pInfo);
-    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
-    if (pMemoryRequirements)
-        cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetBufferMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pInfo))
-        vn_encode_VkBufferMemoryRequirementsInfo2(enc, pInfo);
-    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
-        vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
-}
-
-static inline size_t vn_sizeof_vkGetBufferMemoryRequirements2_reply(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip pInfo */
-    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
-    if (pMemoryRequirements)
-        cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetBufferMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT);
-
-    /* skip device */
-    /* skip pInfo */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
-    } else {
-        pMemoryRequirements = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pInfo);
-    if (pInfo)
-        cmd_size += vn_sizeof_VkImageMemoryRequirementsInfo2(pInfo);
-    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
-    if (pMemoryRequirements)
-        cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetImageMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pInfo))
-        vn_encode_VkImageMemoryRequirementsInfo2(enc, pInfo);
-    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
-        vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
-}
-
-static inline size_t vn_sizeof_vkGetImageMemoryRequirements2_reply(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip pInfo */
-    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
-    if (pMemoryRequirements)
-        cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetImageMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT);
-
-    /* skip device */
-    /* skip pInfo */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
-    } else {
-        pMemoryRequirements = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pInfo);
-    if (pInfo)
-        cmd_size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2(pInfo);
-    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
-    if (pSparseMemoryRequirementCount)
-        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
-    if (pSparseMemoryRequirements) {
-        cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount);
-        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
-            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetImageSparseMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pInfo))
-        vn_encode_VkImageSparseMemoryRequirementsInfo2(enc, pInfo);
-    if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
-        vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
-    if (pSparseMemoryRequirements) {
-        vn_encode_array_size(enc, *pSparseMemoryRequirementCount);
-        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
-            vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip pInfo */
-    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
-    if (pSparseMemoryRequirementCount)
-        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
-    if (pSparseMemoryRequirements) {
-        cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount);
-        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
-            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT);
-
-    /* skip device */
-    /* skip pInfo */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
-    } else {
-        pSparseMemoryRequirementCount = NULL;
-    }
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, *pSparseMemoryRequirementCount);
-        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
-            vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        pSparseMemoryRequirements = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pYcbcrConversion);
-    if (pYcbcrConversion)
-        cmd_size += vn_sizeof_VkSamplerYcbcrConversion(pYcbcrConversion);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateSamplerYcbcrConversion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkSamplerYcbcrConversionCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pYcbcrConversion))
-        vn_encode_VkSamplerYcbcrConversion(enc, pYcbcrConversion);
-}
-
-static inline size_t vn_sizeof_vkCreateSamplerYcbcrConversion_reply(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pYcbcrConversion);
-    if (pYcbcrConversion)
-        cmd_size += vn_sizeof_VkSamplerYcbcrConversion(pYcbcrConversion);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateSamplerYcbcrConversion_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkSamplerYcbcrConversion(dec, pYcbcrConversion);
-    } else {
-        pYcbcrConversion = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkSamplerYcbcrConversion(&ycbcrConversion);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroySamplerYcbcrConversion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkSamplerYcbcrConversion(enc, &ycbcrConversion);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-}
-
-static inline size_t vn_sizeof_vkDestroySamplerYcbcrConversion_reply(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip ycbcrConversion */
-    /* skip pAllocator */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroySamplerYcbcrConversion_reply(struct vn_cs_decoder *dec, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT);
-
-    /* skip device */
-    /* skip ycbcrConversion */
-    /* skip pAllocator */
-}
-
-static inline size_t vn_sizeof_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pQueueInfo);
-    if (pQueueInfo)
-        cmd_size += vn_sizeof_VkDeviceQueueInfo2(pQueueInfo);
-    cmd_size += vn_sizeof_simple_pointer(pQueue);
-    if (pQueue)
-        cmd_size += vn_sizeof_VkQueue(pQueue);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pQueueInfo))
-        vn_encode_VkDeviceQueueInfo2(enc, pQueueInfo);
-    if (vn_encode_simple_pointer(enc, pQueue))
-        vn_encode_VkQueue(enc, pQueue);
-}
-
-static inline size_t vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip pQueueInfo */
-    cmd_size += vn_sizeof_simple_pointer(pQueue);
-    if (pQueue)
-        cmd_size += vn_sizeof_VkQueue(pQueue);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT);
-
-    /* skip device */
-    /* skip pQueueInfo */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkQueue(dec, pQueue);
-    } else {
-        pQueue = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkDescriptorSetLayoutCreateInfo(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pSupport);
-    if (pSupport)
-        cmd_size += vn_sizeof_VkDescriptorSetLayoutSupport_partial(pSupport);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetDescriptorSetLayoutSupport(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkDescriptorSetLayoutCreateInfo(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pSupport))
-        vn_encode_VkDescriptorSetLayoutSupport_partial(enc, pSupport);
-}
-
-static inline size_t vn_sizeof_vkGetDescriptorSetLayoutSupport_reply(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip device */
-    /* skip pCreateInfo */
-    cmd_size += vn_sizeof_simple_pointer(pSupport);
-    if (pSupport)
-        cmd_size += vn_sizeof_VkDescriptorSetLayoutSupport(pSupport);
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkGetDescriptorSetLayoutSupport_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT);
-
-    /* skip device */
-    /* skip pCreateInfo */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkDescriptorSetLayoutSupport(dec, pSupport);
-    } else {
-        pSupport = NULL;
-    }
-}
-
-static inline size_t vn_sizeof_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkRenderPassCreateInfo2(pCreateInfo);
-    cmd_size += vn_sizeof_simple_pointer(pAllocator);
-    if (pAllocator)
-        assert(false);
-    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
-    if (pRenderPass)
-        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkRenderPassCreateInfo2(enc, pCreateInfo);
-    if (vn_encode_simple_pointer(enc, pAllocator))
-        assert(false);
-    if (vn_encode_simple_pointer(enc, pRenderPass))
-        vn_encode_VkRenderPass(enc, pRenderPass);
-}
-
-static inline size_t vn_sizeof_vkCreateRenderPass2_reply(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
-    if (pRenderPass)
-        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkCreateRenderPass2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass2_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pCreateInfo */
-    /* skip pAllocator */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkRenderPass(dec, pRenderPass);
-    } else {
-        pRenderPass = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_simple_pointer(pRenderPassBegin);
-    if (pRenderPassBegin)
-        cmd_size += vn_sizeof_VkRenderPassBeginInfo(pRenderPassBegin);
-    cmd_size += vn_sizeof_simple_pointer(pSubpassBeginInfo);
-    if (pSubpassBeginInfo)
-        cmd_size += vn_sizeof_VkSubpassBeginInfo(pSubpassBeginInfo);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBeginRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    if (vn_encode_simple_pointer(enc, pRenderPassBegin))
-        vn_encode_VkRenderPassBeginInfo(enc, pRenderPassBegin);
-    if (vn_encode_simple_pointer(enc, pSubpassBeginInfo))
-        vn_encode_VkSubpassBeginInfo(enc, pSubpassBeginInfo);
-}
-
-static inline size_t vn_sizeof_vkCmdBeginRenderPass2_reply(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip pRenderPassBegin */
-    /* skip pSubpassBeginInfo */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBeginRenderPass2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT);
-
-    /* skip commandBuffer */
-    /* skip pRenderPassBegin */
-    /* skip pSubpassBeginInfo */
-}
-
-static inline size_t vn_sizeof_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_simple_pointer(pSubpassBeginInfo);
-    if (pSubpassBeginInfo)
-        cmd_size += vn_sizeof_VkSubpassBeginInfo(pSubpassBeginInfo);
-    cmd_size += vn_sizeof_simple_pointer(pSubpassEndInfo);
-    if (pSubpassEndInfo)
-        cmd_size += vn_sizeof_VkSubpassEndInfo(pSubpassEndInfo);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdNextSubpass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    if (vn_encode_simple_pointer(enc, pSubpassBeginInfo))
-        vn_encode_VkSubpassBeginInfo(enc, pSubpassBeginInfo);
-    if (vn_encode_simple_pointer(enc, pSubpassEndInfo))
-        vn_encode_VkSubpassEndInfo(enc, pSubpassEndInfo);
-}
-
-static inline size_t vn_sizeof_vkCmdNextSubpass2_reply(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip pSubpassBeginInfo */
-    /* skip pSubpassEndInfo */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdNextSubpass2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT);
-
-    /* skip commandBuffer */
-    /* skip pSubpassBeginInfo */
-    /* skip pSubpassEndInfo */
-}
-
-static inline size_t vn_sizeof_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_simple_pointer(pSubpassEndInfo);
-    if (pSubpassEndInfo)
-        cmd_size += vn_sizeof_VkSubpassEndInfo(pSubpassEndInfo);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdEndRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    if (vn_encode_simple_pointer(enc, pSubpassEndInfo))
-        vn_encode_VkSubpassEndInfo(enc, pSubpassEndInfo);
-}
-
-static inline size_t vn_sizeof_vkCmdEndRenderPass2_reply(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip pSubpassEndInfo */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdEndRenderPass2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT);
-
-    /* skip commandBuffer */
-    /* skip pSubpassEndInfo */
-}
-
-static inline size_t vn_sizeof_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkSemaphore(&semaphore);
-    cmd_size += vn_sizeof_simple_pointer(pValue); /* out */
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetSemaphoreCounterValue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkSemaphore(enc, &semaphore);
-    vn_encode_simple_pointer(enc, pValue); /* out */
-}
-
-static inline size_t vn_sizeof_vkGetSemaphoreCounterValue_reply(VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip semaphore */
-    cmd_size += vn_sizeof_simple_pointer(pValue);
-    if (pValue)
-        cmd_size += vn_sizeof_uint64_t(pValue);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkGetSemaphoreCounterValue_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip semaphore */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_uint64_t(dec, pValue);
-    } else {
-        pValue = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pWaitInfo);
-    if (pWaitInfo)
-        cmd_size += vn_sizeof_VkSemaphoreWaitInfo(pWaitInfo);
-    cmd_size += vn_sizeof_uint64_t(&timeout);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkWaitSemaphores(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pWaitInfo))
-        vn_encode_VkSemaphoreWaitInfo(enc, pWaitInfo);
-    vn_encode_uint64_t(enc, &timeout);
-}
-
-static inline size_t vn_sizeof_vkWaitSemaphores_reply(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pWaitInfo */
-    /* skip timeout */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkWaitSemaphores_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkWaitSemaphores_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pWaitInfo */
-    /* skip timeout */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pSignalInfo);
-    if (pSignalInfo)
-        cmd_size += vn_sizeof_VkSemaphoreSignalInfo(pSignalInfo);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkSignalSemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pSignalInfo))
-        vn_encode_VkSemaphoreSignalInfo(enc, pSignalInfo);
-}
-
-static inline size_t vn_sizeof_vkSignalSemaphore_reply(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip pSignalInfo */
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkSignalSemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkSignalSemaphore_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip pSignalInfo */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&buffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&offset);
-    cmd_size += vn_sizeof_VkBuffer(&countBuffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&countBufferOffset);
-    cmd_size += vn_sizeof_uint32_t(&maxDrawCount);
-    cmd_size += vn_sizeof_uint32_t(&stride);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdDrawIndirectCount(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkBuffer(enc, &buffer);
-    vn_encode_VkDeviceSize(enc, &offset);
-    vn_encode_VkBuffer(enc, &countBuffer);
-    vn_encode_VkDeviceSize(enc, &countBufferOffset);
-    vn_encode_uint32_t(enc, &maxDrawCount);
-    vn_encode_uint32_t(enc, &stride);
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndirectCount_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-    /* skip countBuffer */
-    /* skip countBufferOffset */
-    /* skip maxDrawCount */
-    /* skip stride */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdDrawIndirectCount_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-    /* skip countBuffer */
-    /* skip countBufferOffset */
-    /* skip maxDrawCount */
-    /* skip stride */
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkBuffer(&buffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&offset);
-    cmd_size += vn_sizeof_VkBuffer(&countBuffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&countBufferOffset);
-    cmd_size += vn_sizeof_uint32_t(&maxDrawCount);
-    cmd_size += vn_sizeof_uint32_t(&stride);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdDrawIndexedIndirectCount(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkBuffer(enc, &buffer);
-    vn_encode_VkDeviceSize(enc, &offset);
-    vn_encode_VkBuffer(enc, &countBuffer);
-    vn_encode_VkDeviceSize(enc, &countBufferOffset);
-    vn_encode_uint32_t(enc, &maxDrawCount);
-    vn_encode_uint32_t(enc, &stride);
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndexedIndirectCount_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-    /* skip countBuffer */
-    /* skip countBufferOffset */
-    /* skip maxDrawCount */
-    /* skip stride */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdDrawIndexedIndirectCount_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT);
-
-    /* skip commandBuffer */
-    /* skip buffer */
-    /* skip offset */
-    /* skip countBuffer */
-    /* skip countBufferOffset */
-    /* skip maxDrawCount */
-    /* skip stride */
-}
-
-static inline size_t vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&firstBinding);
-    cmd_size += vn_sizeof_uint32_t(&bindingCount);
-    if (pBuffers) {
-        cmd_size += vn_sizeof_array_size(bindingCount);
-        for (uint32_t i = 0; i < bindingCount; i++)
-            cmd_size += vn_sizeof_VkBuffer(&pBuffers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    if (pOffsets) {
-        cmd_size += vn_sizeof_array_size(bindingCount);
-        cmd_size += vn_sizeof_VkDeviceSize_array(pOffsets, bindingCount);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    if (pSizes) {
-        cmd_size += vn_sizeof_array_size(bindingCount);
-        cmd_size += vn_sizeof_VkDeviceSize_array(pSizes, bindingCount);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBindTransformFeedbackBuffersEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &firstBinding);
-    vn_encode_uint32_t(enc, &bindingCount);
-    if (pBuffers) {
-        vn_encode_array_size(enc, bindingCount);
-        for (uint32_t i = 0; i < bindingCount; i++)
-            vn_encode_VkBuffer(enc, &pBuffers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (pOffsets) {
-        vn_encode_array_size(enc, bindingCount);
-        vn_encode_VkDeviceSize_array(enc, pOffsets, bindingCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (pSizes) {
-        vn_encode_array_size(enc, bindingCount);
-        vn_encode_VkDeviceSize_array(enc, pSizes, bindingCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT_reply(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip firstBinding */
-    /* skip bindingCount */
-    /* skip pBuffers */
-    /* skip pOffsets */
-    /* skip pSizes */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBindTransformFeedbackBuffersEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT);
-
-    /* skip commandBuffer */
-    /* skip firstBinding */
-    /* skip bindingCount */
-    /* skip pBuffers */
-    /* skip pOffsets */
-    /* skip pSizes */
-}
-
-static inline size_t vn_sizeof_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&firstCounterBuffer);
-    cmd_size += vn_sizeof_uint32_t(&counterBufferCount);
-    if (pCounterBuffers) {
-        cmd_size += vn_sizeof_array_size(counterBufferCount);
-        for (uint32_t i = 0; i < counterBufferCount; i++)
-            cmd_size += vn_sizeof_VkBuffer(&pCounterBuffers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    if (pCounterBufferOffsets) {
-        cmd_size += vn_sizeof_array_size(counterBufferCount);
-        cmd_size += vn_sizeof_VkDeviceSize_array(pCounterBufferOffsets, counterBufferCount);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBeginTransformFeedbackEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &firstCounterBuffer);
-    vn_encode_uint32_t(enc, &counterBufferCount);
-    if (pCounterBuffers) {
-        vn_encode_array_size(enc, counterBufferCount);
-        for (uint32_t i = 0; i < counterBufferCount; i++)
-            vn_encode_VkBuffer(enc, &pCounterBuffers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (pCounterBufferOffsets) {
-        vn_encode_array_size(enc, counterBufferCount);
-        vn_encode_VkDeviceSize_array(enc, pCounterBufferOffsets, counterBufferCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdBeginTransformFeedbackEXT_reply(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip firstCounterBuffer */
-    /* skip counterBufferCount */
-    /* skip pCounterBuffers */
-    /* skip pCounterBufferOffsets */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBeginTransformFeedbackEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT);
-
-    /* skip commandBuffer */
-    /* skip firstCounterBuffer */
-    /* skip counterBufferCount */
-    /* skip pCounterBuffers */
-    /* skip pCounterBufferOffsets */
-}
-
-static inline size_t vn_sizeof_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&firstCounterBuffer);
-    cmd_size += vn_sizeof_uint32_t(&counterBufferCount);
-    if (pCounterBuffers) {
-        cmd_size += vn_sizeof_array_size(counterBufferCount);
-        for (uint32_t i = 0; i < counterBufferCount; i++)
-            cmd_size += vn_sizeof_VkBuffer(&pCounterBuffers[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    if (pCounterBufferOffsets) {
-        cmd_size += vn_sizeof_array_size(counterBufferCount);
-        cmd_size += vn_sizeof_VkDeviceSize_array(pCounterBufferOffsets, counterBufferCount);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdEndTransformFeedbackEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &firstCounterBuffer);
-    vn_encode_uint32_t(enc, &counterBufferCount);
-    if (pCounterBuffers) {
-        vn_encode_array_size(enc, counterBufferCount);
-        for (uint32_t i = 0; i < counterBufferCount; i++)
-            vn_encode_VkBuffer(enc, &pCounterBuffers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (pCounterBufferOffsets) {
-        vn_encode_array_size(enc, counterBufferCount);
-        vn_encode_VkDeviceSize_array(enc, pCounterBufferOffsets, counterBufferCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline size_t vn_sizeof_vkCmdEndTransformFeedbackEXT_reply(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip firstCounterBuffer */
-    /* skip counterBufferCount */
-    /* skip pCounterBuffers */
-    /* skip pCounterBufferOffsets */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdEndTransformFeedbackEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT);
-
-    /* skip commandBuffer */
-    /* skip firstCounterBuffer */
-    /* skip counterBufferCount */
-    /* skip pCounterBuffers */
-    /* skip pCounterBufferOffsets */
-}
-
-static inline size_t vn_sizeof_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
-    cmd_size += vn_sizeof_uint32_t(&query);
-    cmd_size += vn_sizeof_VkFlags(&flags);
-    cmd_size += vn_sizeof_uint32_t(&index);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdBeginQueryIndexedEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkQueryPool(enc, &queryPool);
-    vn_encode_uint32_t(enc, &query);
-    vn_encode_VkFlags(enc, &flags);
-    vn_encode_uint32_t(enc, &index);
-}
-
-static inline size_t vn_sizeof_vkCmdBeginQueryIndexedEXT_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip query */
-    /* skip flags */
-    /* skip index */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdBeginQueryIndexedEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip query */
-    /* skip flags */
-    /* skip index */
-}
-
-static inline size_t vn_sizeof_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
-    cmd_size += vn_sizeof_uint32_t(&query);
-    cmd_size += vn_sizeof_uint32_t(&index);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdEndQueryIndexedEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_VkQueryPool(enc, &queryPool);
-    vn_encode_uint32_t(enc, &query);
-    vn_encode_uint32_t(enc, &index);
-}
-
-static inline size_t vn_sizeof_vkCmdEndQueryIndexedEXT_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip query */
-    /* skip index */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdEndQueryIndexedEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT);
-
-    /* skip commandBuffer */
-    /* skip queryPool */
-    /* skip query */
-    /* skip index */
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
-    cmd_size += vn_sizeof_uint32_t(&instanceCount);
-    cmd_size += vn_sizeof_uint32_t(&firstInstance);
-    cmd_size += vn_sizeof_VkBuffer(&counterBuffer);
-    cmd_size += vn_sizeof_VkDeviceSize(&counterBufferOffset);
-    cmd_size += vn_sizeof_uint32_t(&counterOffset);
-    cmd_size += vn_sizeof_uint32_t(&vertexStride);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCmdDrawIndirectByteCountEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkCommandBuffer(enc, &commandBuffer);
-    vn_encode_uint32_t(enc, &instanceCount);
-    vn_encode_uint32_t(enc, &firstInstance);
-    vn_encode_VkBuffer(enc, &counterBuffer);
-    vn_encode_VkDeviceSize(enc, &counterBufferOffset);
-    vn_encode_uint32_t(enc, &counterOffset);
-    vn_encode_uint32_t(enc, &vertexStride);
-}
-
-static inline size_t vn_sizeof_vkCmdDrawIndirectByteCountEXT_reply(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip commandBuffer */
-    /* skip instanceCount */
-    /* skip firstInstance */
-    /* skip counterBuffer */
-    /* skip counterBufferOffset */
-    /* skip counterOffset */
-    /* skip vertexStride */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCmdDrawIndirectByteCountEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT);
-
-    /* skip commandBuffer */
-    /* skip instanceCount */
-    /* skip firstInstance */
-    /* skip counterBuffer */
-    /* skip counterBufferOffset */
-    /* skip counterOffset */
-    /* skip vertexStride */
-}
-
-static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_VkImage(&image);
-    cmd_size += vn_sizeof_simple_pointer(pProperties);
-    if (pProperties)
-        cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(pProperties);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    vn_encode_VkImage(enc, &image);
-    if (vn_encode_simple_pointer(enc, pProperties))
-        vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(enc, pProperties);
-}
-
-static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkResult ret;
-    cmd_size += vn_sizeof_VkResult(&ret);
-    /* skip device */
-    /* skip image */
-    cmd_size += vn_sizeof_simple_pointer(pProperties);
-    if (pProperties)
-        cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(pProperties);
-
-    return cmd_size;
-}
-
-static inline VkResult vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT);
-
-    VkResult ret;
-    vn_decode_VkResult(dec, &ret);
-    /* skip device */
-    /* skip image */
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkImageDrmFormatModifierPropertiesEXT(dec, pProperties);
-    } else {
-        pProperties = NULL;
-    }
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pInfo);
-    if (pInfo)
-        cmd_size += vn_sizeof_VkBufferDeviceAddressInfo(pInfo);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetBufferOpaqueCaptureAddress(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pInfo))
-        vn_encode_VkBufferDeviceAddressInfo(enc, pInfo);
-}
-
-static inline size_t vn_sizeof_vkGetBufferOpaqueCaptureAddress_reply(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    uint64_t ret;
-    cmd_size += vn_sizeof_uint64_t(&ret);
-    /* skip device */
-    /* skip pInfo */
-
-    return cmd_size;
-}
-
-static inline uint64_t vn_decode_vkGetBufferOpaqueCaptureAddress_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT);
-
-    uint64_t ret;
-    vn_decode_uint64_t(dec, &ret);
-    /* skip device */
-    /* skip pInfo */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pInfo);
-    if (pInfo)
-        cmd_size += vn_sizeof_VkBufferDeviceAddressInfo(pInfo);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetBufferDeviceAddress(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pInfo))
-        vn_encode_VkBufferDeviceAddressInfo(enc, pInfo);
-}
-
-static inline size_t vn_sizeof_vkGetBufferDeviceAddress_reply(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    VkDeviceAddress ret;
-    cmd_size += vn_sizeof_VkDeviceAddress(&ret);
-    /* skip device */
-    /* skip pInfo */
-
-    return cmd_size;
-}
-
-static inline VkDeviceAddress vn_decode_vkGetBufferDeviceAddress_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT);
-
-    VkDeviceAddress ret;
-    vn_decode_VkDeviceAddress(dec, &ret);
-    /* skip device */
-    /* skip pInfo */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_VkDevice(&device);
-    cmd_size += vn_sizeof_simple_pointer(pInfo);
-    if (pInfo)
-        cmd_size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo(pInfo);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_VkDevice(enc, &device);
-    if (vn_encode_simple_pointer(enc, pInfo))
-        vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo(enc, pInfo);
-}
-
-static inline size_t vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    uint64_t ret;
-    cmd_size += vn_sizeof_uint64_t(&ret);
-    /* skip device */
-    /* skip pInfo */
-
-    return cmd_size;
-}
-
-static inline uint64_t vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT);
-
-    uint64_t ret;
-    vn_decode_uint64_t(dec, &ret);
-    /* skip device */
-    /* skip pInfo */
-
-    return ret;
-}
-
-static inline size_t vn_sizeof_vkSetReplyCommandStreamMESA(const VkCommandStreamDescriptionMESA* pStream)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_simple_pointer(pStream);
-    if (pStream)
-        cmd_size += vn_sizeof_VkCommandStreamDescriptionMESA(pStream);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkSetReplyCommandStreamMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const VkCommandStreamDescriptionMESA* pStream)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    if (vn_encode_simple_pointer(enc, pStream))
-        vn_encode_VkCommandStreamDescriptionMESA(enc, pStream);
-}
-
-static inline size_t vn_sizeof_vkSetReplyCommandStreamMESA_reply(const VkCommandStreamDescriptionMESA* pStream)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip pStream */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkSetReplyCommandStreamMESA_reply(struct vn_cs_decoder *dec, const VkCommandStreamDescriptionMESA* pStream)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT);
-
-    /* skip pStream */
-}
-
-static inline size_t vn_sizeof_vkSeekReplyCommandStreamMESA(size_t position)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_size_t(&position);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkSeekReplyCommandStreamMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, size_t position)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_size_t(enc, &position);
-}
-
-static inline size_t vn_sizeof_vkSeekReplyCommandStreamMESA_reply(size_t position)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip position */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkSeekReplyCommandStreamMESA_reply(struct vn_cs_decoder *dec, size_t position)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT);
-
-    /* skip position */
-}
-
-static inline size_t vn_sizeof_vkExecuteCommandStreamsMESA(uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_uint32_t(&streamCount);
-    if (pStreams) {
-        cmd_size += vn_sizeof_array_size(streamCount);
-        for (uint32_t i = 0; i < streamCount; i++)
-            cmd_size += vn_sizeof_VkCommandStreamDescriptionMESA(&pStreams[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    if (pReplyPositions) {
-        cmd_size += vn_sizeof_array_size(streamCount);
-        cmd_size += vn_sizeof_size_t_array(pReplyPositions, streamCount);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_uint32_t(&dependencyCount);
-    if (pDependencies) {
-        cmd_size += vn_sizeof_array_size(dependencyCount);
-        for (uint32_t i = 0; i < dependencyCount; i++)
-            cmd_size += vn_sizeof_VkCommandStreamDependencyMESA(&pDependencies[i]);
-    } else {
-        cmd_size += vn_sizeof_array_size(0);
-    }
-    cmd_size += vn_sizeof_VkFlags(&flags);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkExecuteCommandStreamsMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_uint32_t(enc, &streamCount);
-    if (pStreams) {
-        vn_encode_array_size(enc, streamCount);
-        for (uint32_t i = 0; i < streamCount; i++)
-            vn_encode_VkCommandStreamDescriptionMESA(enc, &pStreams[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (pReplyPositions) {
-        vn_encode_array_size(enc, streamCount);
-        vn_encode_size_t_array(enc, pReplyPositions, streamCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &dependencyCount);
-    if (pDependencies) {
-        vn_encode_array_size(enc, dependencyCount);
-        for (uint32_t i = 0; i < dependencyCount; i++)
-            vn_encode_VkCommandStreamDependencyMESA(enc, &pDependencies[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_VkFlags(enc, &flags);
-}
-
-static inline size_t vn_sizeof_vkExecuteCommandStreamsMESA_reply(uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip streamCount */
-    /* skip pStreams */
-    /* skip pReplyPositions */
-    /* skip dependencyCount */
-    /* skip pDependencies */
-    /* skip flags */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkExecuteCommandStreamsMESA_reply(struct vn_cs_decoder *dec, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT);
-
-    /* skip streamCount */
-    /* skip pStreams */
-    /* skip pReplyPositions */
-    /* skip dependencyCount */
-    /* skip pDependencies */
-    /* skip flags */
-}
-
-static inline size_t vn_sizeof_vkCreateRingMESA(uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_uint64_t(&ring);
-    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
-    if (pCreateInfo)
-        cmd_size += vn_sizeof_VkRingCreateInfoMESA(pCreateInfo);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkCreateRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_uint64_t(enc, &ring);
-    if (vn_encode_simple_pointer(enc, pCreateInfo))
-        vn_encode_VkRingCreateInfoMESA(enc, pCreateInfo);
-}
-
-static inline size_t vn_sizeof_vkCreateRingMESA_reply(uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip ring */
-    /* skip pCreateInfo */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkCreateRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkCreateRingMESA_EXT);
-
-    /* skip ring */
-    /* skip pCreateInfo */
-}
-
-static inline size_t vn_sizeof_vkDestroyRingMESA(uint64_t ring)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_uint64_t(&ring);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkDestroyRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_uint64_t(enc, &ring);
-}
-
-static inline size_t vn_sizeof_vkDestroyRingMESA_reply(uint64_t ring)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip ring */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkDestroyRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkDestroyRingMESA_EXT);
-
-    /* skip ring */
-}
-
-static inline size_t vn_sizeof_vkNotifyRingMESA(uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_uint64_t(&ring);
-    cmd_size += vn_sizeof_uint32_t(&seqno);
-    cmd_size += vn_sizeof_VkFlags(&flags);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkNotifyRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_uint64_t(enc, &ring);
-    vn_encode_uint32_t(enc, &seqno);
-    vn_encode_VkFlags(enc, &flags);
-}
-
-static inline size_t vn_sizeof_vkNotifyRingMESA_reply(uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip ring */
-    /* skip seqno */
-    /* skip flags */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkNotifyRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkNotifyRingMESA_EXT);
-
-    /* skip ring */
-    /* skip seqno */
-    /* skip flags */
-}
-
-static inline size_t vn_sizeof_vkWriteRingExtraMESA(uint64_t ring, size_t offset, uint32_t value)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT;
-    const VkFlags cmd_flags = 0;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
-
-    cmd_size += vn_sizeof_uint64_t(&ring);
-    cmd_size += vn_sizeof_size_t(&offset);
-    cmd_size += vn_sizeof_uint32_t(&value);
-
-    return cmd_size;
-}
-
-static inline void vn_encode_vkWriteRingExtraMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, size_t offset, uint32_t value)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT;
-
-    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
-    vn_encode_VkFlags(enc, &cmd_flags);
-
-    vn_encode_uint64_t(enc, &ring);
-    vn_encode_size_t(enc, &offset);
-    vn_encode_uint32_t(enc, &value);
-}
-
-static inline size_t vn_sizeof_vkWriteRingExtraMESA_reply(uint64_t ring, size_t offset, uint32_t value)
-{
-    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT;
-    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
-
-    /* skip ring */
-    /* skip offset */
-    /* skip value */
-
-    return cmd_size;
-}
-
-static inline void vn_decode_vkWriteRingExtraMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, size_t offset, uint32_t value)
-{
-    VkCommandTypeEXT command_type;
-    vn_decode_VkCommandTypeEXT(dec, &command_type);
-    assert(command_type == VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT);
-
-    /* skip ring */
-    /* skip offset */
-    /* skip value */
-}
-
-#endif /* VN_PROTOCOL_DRIVER_COMMANDS_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_cs.h b/src/virtio/venus-protocol/vn_protocol_driver_cs.h
index fa63ab6..95b689d 100644 (file)
--- a/src/virtio/venus-protocol/vn_protocol_driver_cs.h
+++ b/src/virtio/venus-protocol/vn_protocol_driver_cs.h
@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_defines.h b/src/virtio/venus-protocol/vn_protocol_driver_defines.h
index 546a81f..ef5bcfe 100644 (file)
--- a/src/virtio/venus-protocol/vn_protocol_driver_defines.h
+++ b/src/virtio/venus-protocol/vn_protocol_driver_defines.h
@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC
@@ -14,6 +14,8 @@
 
 #include "vn_protocol_driver_cs.h"
 
+#define VN_SUBMIT_LOCAL_CMD_SIZE 256
+
 /* VkStructureType */
 #define VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA ((VkStructureType)1000384000)
 

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h
new file mode 100644 (file)
index 0000000..7941d03
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h
@@ -0,0 +1,398 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_DESCRIPTOR_POOL_H
+#define VN_PROTOCOL_DRIVER_DESCRIPTOR_POOL_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkDescriptorPoolSize */
+
+static inline size_t
+vn_sizeof_VkDescriptorPoolSize(const VkDescriptorPoolSize *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkDescriptorType(&val->type);
+    size += vn_sizeof_uint32_t(&val->descriptorCount);
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorPoolSize(struct vn_cs_encoder *enc, const VkDescriptorPoolSize *val)
+{
+    vn_encode_VkDescriptorType(enc, &val->type);
+    vn_encode_uint32_t(enc, &val->descriptorCount);
+}
+
+/* struct VkDescriptorPoolCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorPoolCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorPoolCreateInfo_self(const VkDescriptorPoolCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->maxSets);
+    size += vn_sizeof_uint32_t(&val->poolSizeCount);
+    if (val->pPoolSizes) {
+        size += vn_sizeof_array_size(val->poolSizeCount);
+        for (uint32_t i = 0; i < val->poolSizeCount; i++)
+            size += vn_sizeof_VkDescriptorPoolSize(&val->pPoolSizes[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorPoolCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorPoolCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->maxSets);
+    vn_encode_uint32_t(enc, &val->poolSizeCount);
+    if (val->pPoolSizes) {
+        vn_encode_array_size(enc, val->poolSizeCount);
+        for (uint32_t i = 0; i < val->poolSizeCount; i++)
+            vn_encode_VkDescriptorPoolSize(enc, &val->pPoolSizes[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDescriptorPoolCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO });
+    vn_encode_VkDescriptorPoolCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorPoolCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkDescriptorPoolCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pDescriptorPool);
+    if (pDescriptorPool)
+        cmd_size += vn_sizeof_VkDescriptorPool(pDescriptorPool);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkDescriptorPoolCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pDescriptorPool))
+        vn_encode_VkDescriptorPool(enc, pDescriptorPool);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorPool_reply(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pDescriptorPool);
+    if (pDescriptorPool)
+        cmd_size += vn_sizeof_VkDescriptorPool(pDescriptorPool);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDescriptorPool(dec, pDescriptorPool);
+    } else {
+        pDescriptorPool = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDescriptorPool(enc, &descriptorPool);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorPool_reply(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT);
+
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDescriptorPool(enc, &descriptorPool);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkResetDescriptorPool_reply(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkResetDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetDescriptorPool_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip flags */
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateDescriptorPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorPool);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorPool_reply(device, pCreateInfo, pAllocator, pDescriptorPool) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyDescriptorPool(&submit->command, cmd_flags, device, descriptorPool, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorPool_reply(device, descriptorPool, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetDescriptorPool(device, descriptorPool, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetDescriptorPool(&submit->command, cmd_flags, device, descriptorPool, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetDescriptorPool_reply(device, descriptorPool, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorPool, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateDescriptorPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pDescriptorPool);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorPool(vn_instance, 0, device, pCreateInfo, pAllocator, pDescriptorPool, &submit);
+}
+
+static inline void vn_call_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyDescriptorPool_reply(&submit.reply, device, descriptorPool, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorPool(vn_instance, 0, device, descriptorPool, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkResetDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, flags, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkResetDescriptorPool_reply(&submit.reply, device, descriptorPool, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkResetDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetDescriptorPool(vn_instance, 0, device, descriptorPool, flags, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_DESCRIPTOR_POOL_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_descriptor_set.h b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_set.h
new file mode 100644 (file)
index 0000000..9b6fceb
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_set.h
@@ -0,0 +1,744 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_H
+#define VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/*
+ * These structs/unions/commands are not included
+ *
+ *   vkUpdateDescriptorSetWithTemplate
+ */
+
+/* struct VkDescriptorSetVariableDescriptorCountAllocateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->descriptorSetCount);
+    if (val->pDescriptorCounts) {
+        size += vn_sizeof_array_size(val->descriptorSetCount);
+        size += vn_sizeof_uint32_t_array(val->pDescriptorCounts, val->descriptorSetCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->descriptorSetCount);
+    if (val->pDescriptorCounts) {
+        vn_encode_array_size(enc, val->descriptorSetCount);
+        vn_encode_uint32_t_array(enc, val->pDescriptorCounts, val->descriptorSetCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO });
+    vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(enc, val);
+}
+
+/* struct VkDescriptorSetAllocateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetAllocateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDescriptorSetAllocateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self((const VkDescriptorSetVariableDescriptorCountAllocateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetAllocateInfo_self(const VkDescriptorSetAllocateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDescriptorPool(&val->descriptorPool);
+    size += vn_sizeof_uint32_t(&val->descriptorSetCount);
+    if (val->pSetLayouts) {
+        size += vn_sizeof_array_size(val->descriptorSetCount);
+        for (uint32_t i = 0; i < val->descriptorSetCount; i++)
+            size += vn_sizeof_VkDescriptorSetLayout(&val->pSetLayouts[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetAllocateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetAllocateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDescriptorSetAllocateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(enc, (const VkDescriptorSetVariableDescriptorCountAllocateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetAllocateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetAllocateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkDescriptorPool(enc, &val->descriptorPool);
+    vn_encode_uint32_t(enc, &val->descriptorSetCount);
+    if (val->pSetLayouts) {
+        vn_encode_array_size(enc, val->descriptorSetCount);
+        for (uint32_t i = 0; i < val->descriptorSetCount; i++)
+            vn_encode_VkDescriptorSetLayout(enc, &val->pSetLayouts[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDescriptorSetAllocateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetAllocateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO });
+    vn_encode_VkDescriptorSetAllocateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorSetAllocateInfo_self(enc, val);
+}
+
+/* struct VkDescriptorImageInfo */
+
+static inline size_t
+vn_sizeof_VkDescriptorImageInfo(const VkDescriptorImageInfo *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkSampler(&val->sampler);
+    size += vn_sizeof_VkImageView(&val->imageView);
+    size += vn_sizeof_VkImageLayout(&val->imageLayout);
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorImageInfo(struct vn_cs_encoder *enc, const VkDescriptorImageInfo *val)
+{
+    vn_encode_VkSampler(enc, &val->sampler);
+    vn_encode_VkImageView(enc, &val->imageView);
+    vn_encode_VkImageLayout(enc, &val->imageLayout);
+}
+
+/* struct VkDescriptorBufferInfo */
+
+static inline size_t
+vn_sizeof_VkDescriptorBufferInfo(const VkDescriptorBufferInfo *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkBuffer(&val->buffer);
+    size += vn_sizeof_VkDeviceSize(&val->offset);
+    size += vn_sizeof_VkDeviceSize(&val->range);
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorBufferInfo(struct vn_cs_encoder *enc, const VkDescriptorBufferInfo *val)
+{
+    vn_encode_VkBuffer(enc, &val->buffer);
+    vn_encode_VkDeviceSize(enc, &val->offset);
+    vn_encode_VkDeviceSize(enc, &val->range);
+}
+
+/* struct VkWriteDescriptorSet chain */
+
+static inline size_t
+vn_sizeof_VkWriteDescriptorSet_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkWriteDescriptorSet_self(const VkWriteDescriptorSet *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDescriptorSet(&val->dstSet);
+    size += vn_sizeof_uint32_t(&val->dstBinding);
+    size += vn_sizeof_uint32_t(&val->dstArrayElement);
+    size += vn_sizeof_uint32_t(&val->descriptorCount);
+    size += vn_sizeof_VkDescriptorType(&val->descriptorType);
+    if (val->pImageInfo) {
+        size += vn_sizeof_array_size(val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            size += vn_sizeof_VkDescriptorImageInfo(&val->pImageInfo[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    if (val->pBufferInfo) {
+        size += vn_sizeof_array_size(val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            size += vn_sizeof_VkDescriptorBufferInfo(&val->pBufferInfo[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    if (val->pTexelBufferView) {
+        size += vn_sizeof_array_size(val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            size += vn_sizeof_VkBufferView(&val->pTexelBufferView[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkWriteDescriptorSet(const VkWriteDescriptorSet *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkWriteDescriptorSet_pnext(val->pNext);
+    size += vn_sizeof_VkWriteDescriptorSet_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkWriteDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkWriteDescriptorSet_self(struct vn_cs_encoder *enc, const VkWriteDescriptorSet *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkDescriptorSet(enc, &val->dstSet);
+    vn_encode_uint32_t(enc, &val->dstBinding);
+    vn_encode_uint32_t(enc, &val->dstArrayElement);
+    vn_encode_uint32_t(enc, &val->descriptorCount);
+    vn_encode_VkDescriptorType(enc, &val->descriptorType);
+    if (val->pImageInfo) {
+        vn_encode_array_size(enc, val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            vn_encode_VkDescriptorImageInfo(enc, &val->pImageInfo[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (val->pBufferInfo) {
+        vn_encode_array_size(enc, val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            vn_encode_VkDescriptorBufferInfo(enc, &val->pBufferInfo[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (val->pTexelBufferView) {
+        vn_encode_array_size(enc, val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            vn_encode_VkBufferView(enc, &val->pTexelBufferView[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkWriteDescriptorSet(struct vn_cs_encoder *enc, const VkWriteDescriptorSet *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET });
+    vn_encode_VkWriteDescriptorSet_pnext(enc, val->pNext);
+    vn_encode_VkWriteDescriptorSet_self(enc, val);
+}
+
+/* struct VkCopyDescriptorSet chain */
+
+static inline size_t
+vn_sizeof_VkCopyDescriptorSet_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkCopyDescriptorSet_self(const VkCopyDescriptorSet *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDescriptorSet(&val->srcSet);
+    size += vn_sizeof_uint32_t(&val->srcBinding);
+    size += vn_sizeof_uint32_t(&val->srcArrayElement);
+    size += vn_sizeof_VkDescriptorSet(&val->dstSet);
+    size += vn_sizeof_uint32_t(&val->dstBinding);
+    size += vn_sizeof_uint32_t(&val->dstArrayElement);
+    size += vn_sizeof_uint32_t(&val->descriptorCount);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkCopyDescriptorSet(const VkCopyDescriptorSet *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkCopyDescriptorSet_pnext(val->pNext);
+    size += vn_sizeof_VkCopyDescriptorSet_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkCopyDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkCopyDescriptorSet_self(struct vn_cs_encoder *enc, const VkCopyDescriptorSet *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkDescriptorSet(enc, &val->srcSet);
+    vn_encode_uint32_t(enc, &val->srcBinding);
+    vn_encode_uint32_t(enc, &val->srcArrayElement);
+    vn_encode_VkDescriptorSet(enc, &val->dstSet);
+    vn_encode_uint32_t(enc, &val->dstBinding);
+    vn_encode_uint32_t(enc, &val->dstArrayElement);
+    vn_encode_uint32_t(enc, &val->descriptorCount);
+}
+
+static inline void
+vn_encode_VkCopyDescriptorSet(struct vn_cs_encoder *enc, const VkCopyDescriptorSet *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET });
+    vn_encode_VkCopyDescriptorSet_pnext(enc, val->pNext);
+    vn_encode_VkCopyDescriptorSet_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pAllocateInfo);
+    if (pAllocateInfo)
+        cmd_size += vn_sizeof_VkDescriptorSetAllocateInfo(pAllocateInfo);
+    if (pDescriptorSets) {
+        cmd_size += vn_sizeof_array_size(pAllocateInfo->descriptorSetCount);
+        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
+            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkAllocateDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pAllocateInfo))
+        vn_encode_VkDescriptorSetAllocateInfo(enc, pAllocateInfo);
+    if (pDescriptorSets) {
+        vn_encode_array_size(enc, pAllocateInfo->descriptorSetCount);
+        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
+            vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkAllocateDescriptorSets_reply(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pAllocateInfo */
+    if (pDescriptorSets) {
+        cmd_size += vn_sizeof_array_size(pAllocateInfo->descriptorSetCount);
+        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
+            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkAllocateDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pAllocateInfo */
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, pAllocateInfo->descriptorSetCount);
+        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
+            vn_decode_VkDescriptorSet(dec, &pDescriptorSets[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pDescriptorSets = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
+    cmd_size += vn_sizeof_uint32_t(&descriptorSetCount);
+    if (pDescriptorSets) {
+        cmd_size += vn_sizeof_array_size(descriptorSetCount);
+        for (uint32_t i = 0; i < descriptorSetCount; i++)
+            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkFreeDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDescriptorPool(enc, &descriptorPool);
+    vn_encode_uint32_t(enc, &descriptorSetCount);
+    if (pDescriptorSets) {
+        vn_encode_array_size(enc, descriptorSetCount);
+        for (uint32_t i = 0; i < descriptorSetCount; i++)
+            vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkFreeDescriptorSets_reply(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip descriptorSetCount */
+    /* skip pDescriptorSets */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkFreeDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip descriptorSetCount */
+    /* skip pDescriptorSets */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&descriptorWriteCount);
+    if (pDescriptorWrites) {
+        cmd_size += vn_sizeof_array_size(descriptorWriteCount);
+        for (uint32_t i = 0; i < descriptorWriteCount; i++)
+            cmd_size += vn_sizeof_VkWriteDescriptorSet(&pDescriptorWrites[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_uint32_t(&descriptorCopyCount);
+    if (pDescriptorCopies) {
+        cmd_size += vn_sizeof_array_size(descriptorCopyCount);
+        for (uint32_t i = 0; i < descriptorCopyCount; i++)
+            cmd_size += vn_sizeof_VkCopyDescriptorSet(&pDescriptorCopies[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkUpdateDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &descriptorWriteCount);
+    if (pDescriptorWrites) {
+        vn_encode_array_size(enc, descriptorWriteCount);
+        for (uint32_t i = 0; i < descriptorWriteCount; i++)
+            vn_encode_VkWriteDescriptorSet(enc, &pDescriptorWrites[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &descriptorCopyCount);
+    if (pDescriptorCopies) {
+        vn_encode_array_size(enc, descriptorCopyCount);
+        for (uint32_t i = 0; i < descriptorCopyCount; i++)
+            vn_encode_VkCopyDescriptorSet(enc, &pDescriptorCopies[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkUpdateDescriptorSets_reply(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip descriptorWriteCount */
+    /* skip pDescriptorWrites */
+    /* skip descriptorCopyCount */
+    /* skip pDescriptorCopies */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkUpdateDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT);
+
+    /* skip device */
+    /* skip descriptorWriteCount */
+    /* skip pDescriptorWrites */
+    /* skip descriptorCopyCount */
+    /* skip pDescriptorCopies */
+}
+
+static inline void vn_submit_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkAllocateDescriptorSets(&submit->command, cmd_flags, device, pAllocateInfo, pDescriptorSets);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateDescriptorSets_reply(device, pAllocateInfo, pDescriptorSets) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkFreeDescriptorSets(&submit->command, cmd_flags, device, descriptorPool, descriptorSetCount, pDescriptorSets);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeDescriptorSets_reply(device, descriptorPool, descriptorSetCount, pDescriptorSets) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkUpdateDescriptorSets(&submit->command, cmd_flags, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUpdateDescriptorSets_reply(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkAllocateDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pDescriptorSets, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkAllocateDescriptorSets_reply(&submit.reply, device, pAllocateInfo, pDescriptorSets);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkAllocateDescriptorSets(vn_instance, 0, device, pAllocateInfo, pDescriptorSets, &submit);
+}
+
+static inline VkResult vn_call_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkFreeDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, descriptorSetCount, pDescriptorSets, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkFreeDescriptorSets_reply(&submit.reply, device, descriptorPool, descriptorSetCount, pDescriptorSets);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkFreeDescriptorSets(vn_instance, 0, device, descriptorPool, descriptorSetCount, pDescriptorSets, &submit);
+}
+
+static inline void vn_call_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkUpdateDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkUpdateDescriptorSets_reply(&submit.reply, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkUpdateDescriptorSets(vn_instance, 0, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_descriptor_set_layout.h b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_set_layout.h
new file mode 100644 (file)
index 0000000..fd446bd
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_set_layout.h
@@ -0,0 +1,802 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_LAYOUT_H
+#define VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_LAYOUT_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkDescriptorSetLayoutBinding */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->binding);
+    size += vn_sizeof_VkDescriptorType(&val->descriptorType);
+    size += vn_sizeof_uint32_t(&val->descriptorCount);
+    size += vn_sizeof_VkFlags(&val->stageFlags);
+    if (val->pImmutableSamplers) {
+        size += vn_sizeof_array_size(val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            size += vn_sizeof_VkSampler(&val->pImmutableSamplers[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutBinding(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBinding *val)
+{
+    vn_encode_uint32_t(enc, &val->binding);
+    vn_encode_VkDescriptorType(enc, &val->descriptorType);
+    vn_encode_uint32_t(enc, &val->descriptorCount);
+    vn_encode_VkFlags(enc, &val->stageFlags);
+    if (val->pImmutableSamplers) {
+        vn_encode_array_size(enc, val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            vn_encode_VkSampler(enc, &val->pImmutableSamplers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+/* struct VkDescriptorSetLayoutBindingFlagsCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->bindingCount);
+    if (val->pBindingFlags) {
+        size += vn_sizeof_array_size(val->bindingCount);
+        for (uint32_t i = 0; i < val->bindingCount; i++)
+            size += vn_sizeof_VkFlags(&val->pBindingFlags[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->bindingCount);
+    if (val->pBindingFlags) {
+        vn_encode_array_size(enc, val->bindingCount);
+        for (uint32_t i = 0; i < val->bindingCount; i++)
+            vn_encode_VkFlags(enc, &val->pBindingFlags[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO });
+    vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(enc, val);
+}
+
+/* struct VkDescriptorSetLayoutCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self((const VkDescriptorSetLayoutBindingFlagsCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutCreateInfo_self(const VkDescriptorSetLayoutCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->bindingCount);
+    if (val->pBindings) {
+        size += vn_sizeof_array_size(val->bindingCount);
+        for (uint32_t i = 0; i < val->bindingCount; i++)
+            size += vn_sizeof_VkDescriptorSetLayoutBinding(&val->pBindings[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(enc, (const VkDescriptorSetLayoutBindingFlagsCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->bindingCount);
+    if (val->pBindings) {
+        vn_encode_array_size(enc, val->bindingCount);
+        for (uint32_t i = 0; i < val->bindingCount; i++)
+            vn_encode_VkDescriptorSetLayoutBinding(enc, &val->pBindings[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO });
+    vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorSetLayoutCreateInfo_self(enc, val);
+}
+
+/* struct VkDescriptorSetVariableDescriptorCountLayoutSupport chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->maxVariableDescriptorCount);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(struct vn_cs_decoder *dec, VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->maxVariableDescriptorCount);
+}
+
+static inline void
+vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport(struct vn_cs_decoder *dec, VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
+
+    assert(val->sType == stype);
+    vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(dec, val->pNext);
+    vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->maxVariableDescriptorCount */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_partial(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(val->pNext);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->maxVariableDescriptorCount */
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_partial(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT });
+    vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(enc, val->pNext);
+    vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(enc, val);
+}
+
+/* struct VkDescriptorSetLayoutSupport chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext(pnext->pNext);
+            size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self((const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport_self(const VkDescriptorSetLayoutSupport *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->supported);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetLayoutSupport_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkDescriptorSetLayoutSupport_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return;
+
+    vn_decode_VkStructureType(dec, &stype);
+    while (true) {
+        assert(pnext);
+        if (pnext->sType == stype)
+            break;
+    }
+
+    switch ((int32_t)pnext->sType) {
+    case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+        vn_decode_VkDescriptorSetLayoutSupport_pnext(dec, pnext->pNext);
+        vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(dec, (VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_decode_VkDescriptorSetLayoutSupport_self(struct vn_cs_decoder *dec, VkDescriptorSetLayoutSupport *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->supported);
+}
+
+static inline void
+vn_decode_VkDescriptorSetLayoutSupport(struct vn_cs_decoder *dec, VkDescriptorSetLayoutSupport *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT);
+
+    assert(val->sType == stype);
+    vn_decode_VkDescriptorSetLayoutSupport_pnext(dec, val->pNext);
+    vn_decode_VkDescriptorSetLayoutSupport_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial((const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport_self_partial(const VkDescriptorSetLayoutSupport *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->supported */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport_partial(const VkDescriptorSetLayoutSupport *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(val->pNext);
+    size += vn_sizeof_VkDescriptorSetLayoutSupport_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(enc, (const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutSupport_self_partial(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutSupport *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->supported */
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutSupport_partial(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutSupport *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT });
+    vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(enc, val->pNext);
+    vn_encode_VkDescriptorSetLayoutSupport_self_partial(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkDescriptorSetLayoutCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pSetLayout);
+    if (pSetLayout)
+        cmd_size += vn_sizeof_VkDescriptorSetLayout(pSetLayout);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateDescriptorSetLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkDescriptorSetLayoutCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pSetLayout))
+        vn_encode_VkDescriptorSetLayout(enc, pSetLayout);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorSetLayout_reply(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pSetLayout);
+    if (pSetLayout)
+        cmd_size += vn_sizeof_VkDescriptorSetLayout(pSetLayout);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateDescriptorSetLayout_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDescriptorSetLayout(dec, pSetLayout);
+    } else {
+        pSetLayout = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDescriptorSetLayout(&descriptorSetLayout);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyDescriptorSetLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDescriptorSetLayout(enc, &descriptorSetLayout);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorSetLayout_reply(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip descriptorSetLayout */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyDescriptorSetLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT);
+
+    /* skip device */
+    /* skip descriptorSetLayout */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkDescriptorSetLayoutCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pSupport);
+    if (pSupport)
+        cmd_size += vn_sizeof_VkDescriptorSetLayoutSupport_partial(pSupport);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetDescriptorSetLayoutSupport(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkDescriptorSetLayoutCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pSupport))
+        vn_encode_VkDescriptorSetLayoutSupport_partial(enc, pSupport);
+}
+
+static inline size_t vn_sizeof_vkGetDescriptorSetLayoutSupport_reply(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pCreateInfo */
+    cmd_size += vn_sizeof_simple_pointer(pSupport);
+    if (pSupport)
+        cmd_size += vn_sizeof_VkDescriptorSetLayoutSupport(pSupport);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetDescriptorSetLayoutSupport_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT);
+
+    /* skip device */
+    /* skip pCreateInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDescriptorSetLayoutSupport(dec, pSupport);
+    } else {
+        pSupport = NULL;
+    }
+}
+
+static inline void vn_submit_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateDescriptorSetLayout(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSetLayout);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorSetLayout_reply(device, pCreateInfo, pAllocator, pSetLayout) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyDescriptorSetLayout(&submit->command, cmd_flags, device, descriptorSetLayout, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorSetLayout_reply(device, descriptorSetLayout, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetDescriptorSetLayoutSupport(&submit->command, cmd_flags, device, pCreateInfo, pSupport);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDescriptorSetLayoutSupport_reply(device, pCreateInfo, pSupport) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorSetLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSetLayout, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateDescriptorSetLayout_reply(&submit.reply, device, pCreateInfo, pAllocator, pSetLayout);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorSetLayout(vn_instance, 0, device, pCreateInfo, pAllocator, pSetLayout, &submit);
+}
+
+static inline void vn_call_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorSetLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorSetLayout, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyDescriptorSetLayout_reply(&submit.reply, device, descriptorSetLayout, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorSetLayout(vn_instance, 0, device, descriptorSetLayout, pAllocator, &submit);
+}
+
+static inline void vn_call_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDescriptorSetLayoutSupport(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pSupport, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetDescriptorSetLayoutSupport_reply(&submit.reply, device, pCreateInfo, pSupport);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDescriptorSetLayoutSupport(vn_instance, 0, device, pCreateInfo, pSupport, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_LAYOUT_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_descriptor_update_template.h b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_update_template.h
new file mode 100644 (file)
index 0000000..4cec93c
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_update_template.h
@@ -0,0 +1,320 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_DESCRIPTOR_UPDATE_TEMPLATE_H
+#define VN_PROTOCOL_DRIVER_DESCRIPTOR_UPDATE_TEMPLATE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkDescriptorUpdateTemplateEntry */
+
+static inline size_t
+vn_sizeof_VkDescriptorUpdateTemplateEntry(const VkDescriptorUpdateTemplateEntry *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->dstBinding);
+    size += vn_sizeof_uint32_t(&val->dstArrayElement);
+    size += vn_sizeof_uint32_t(&val->descriptorCount);
+    size += vn_sizeof_VkDescriptorType(&val->descriptorType);
+    size += vn_sizeof_size_t(&val->offset);
+    size += vn_sizeof_size_t(&val->stride);
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorUpdateTemplateEntry(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateEntry *val)
+{
+    vn_encode_uint32_t(enc, &val->dstBinding);
+    vn_encode_uint32_t(enc, &val->dstArrayElement);
+    vn_encode_uint32_t(enc, &val->descriptorCount);
+    vn_encode_VkDescriptorType(enc, &val->descriptorType);
+    vn_encode_size_t(enc, &val->offset);
+    vn_encode_size_t(enc, &val->stride);
+}
+
+/* struct VkDescriptorUpdateTemplateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_self(const VkDescriptorUpdateTemplateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->descriptorUpdateEntryCount);
+    if (val->pDescriptorUpdateEntries) {
+        size += vn_sizeof_array_size(val->descriptorUpdateEntryCount);
+        for (uint32_t i = 0; i < val->descriptorUpdateEntryCount; i++)
+            size += vn_sizeof_VkDescriptorUpdateTemplateEntry(&val->pDescriptorUpdateEntries[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_VkDescriptorUpdateTemplateType(&val->templateType);
+    size += vn_sizeof_VkDescriptorSetLayout(&val->descriptorSetLayout);
+    size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);
+    size += vn_sizeof_VkPipelineLayout(&val->pipelineLayout);
+    size += vn_sizeof_uint32_t(&val->set);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorUpdateTemplateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorUpdateTemplateCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->descriptorUpdateEntryCount);
+    if (val->pDescriptorUpdateEntries) {
+        vn_encode_array_size(enc, val->descriptorUpdateEntryCount);
+        for (uint32_t i = 0; i < val->descriptorUpdateEntryCount; i++)
+            vn_encode_VkDescriptorUpdateTemplateEntry(enc, &val->pDescriptorUpdateEntries[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkDescriptorUpdateTemplateType(enc, &val->templateType);
+    vn_encode_VkDescriptorSetLayout(enc, &val->descriptorSetLayout);
+    vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);
+    vn_encode_VkPipelineLayout(enc, &val->pipelineLayout);
+    vn_encode_uint32_t(enc, &val->set);
+}
+
+static inline void
+vn_encode_VkDescriptorUpdateTemplateCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO });
+    vn_encode_VkDescriptorUpdateTemplateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorUpdateTemplateCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pDescriptorUpdateTemplate);
+    if (pDescriptorUpdateTemplate)
+        cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(pDescriptorUpdateTemplate);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateDescriptorUpdateTemplate(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkDescriptorUpdateTemplateCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pDescriptorUpdateTemplate))
+        vn_encode_VkDescriptorUpdateTemplate(enc, pDescriptorUpdateTemplate);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorUpdateTemplate_reply(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pDescriptorUpdateTemplate);
+    if (pDescriptorUpdateTemplate)
+        cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(pDescriptorUpdateTemplate);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateDescriptorUpdateTemplate_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDescriptorUpdateTemplate(dec, pDescriptorUpdateTemplate);
+    } else {
+        pDescriptorUpdateTemplate = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(&descriptorUpdateTemplate);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyDescriptorUpdateTemplate(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDescriptorUpdateTemplate(enc, &descriptorUpdateTemplate);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorUpdateTemplate_reply(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip descriptorUpdateTemplate */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyDescriptorUpdateTemplate_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT);
+
+    /* skip device */
+    /* skip descriptorUpdateTemplate */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateDescriptorUpdateTemplate(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorUpdateTemplate_reply(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyDescriptorUpdateTemplate(&submit->command, cmd_flags, device, descriptorUpdateTemplate, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorUpdateTemplate_reply(device, descriptorUpdateTemplate, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorUpdateTemplate(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateDescriptorUpdateTemplate_reply(&submit.reply, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorUpdateTemplate(vn_instance, 0, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, &submit);
+}
+
+static inline void vn_call_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorUpdateTemplate(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorUpdateTemplate, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyDescriptorUpdateTemplate_reply(&submit.reply, device, descriptorUpdateTemplate, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorUpdateTemplate(vn_instance, 0, device, descriptorUpdateTemplate, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_DESCRIPTOR_UPDATE_TEMPLATE_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_device.h b/src/virtio/venus-protocol/vn_protocol_driver_device.h
new file mode 100644 (file)
index 0000000..8feef22
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_device.h
@@ -0,0 +1,13588 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_DEVICE_H
+#define VN_PROTOCOL_DRIVER_DEVICE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/*
+ * These structs/unions/commands are not included
+ *
+ *   vkGetDeviceProcAddr
+ */
+
+/* struct VkPhysicalDeviceLimits */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->maxImageDimension1D);
+    size += vn_sizeof_uint32_t(&val->maxImageDimension2D);
+    size += vn_sizeof_uint32_t(&val->maxImageDimension3D);
+    size += vn_sizeof_uint32_t(&val->maxImageDimensionCube);
+    size += vn_sizeof_uint32_t(&val->maxImageArrayLayers);
+    size += vn_sizeof_uint32_t(&val->maxTexelBufferElements);
+    size += vn_sizeof_uint32_t(&val->maxUniformBufferRange);
+    size += vn_sizeof_uint32_t(&val->maxStorageBufferRange);
+    size += vn_sizeof_uint32_t(&val->maxPushConstantsSize);
+    size += vn_sizeof_uint32_t(&val->maxMemoryAllocationCount);
+    size += vn_sizeof_uint32_t(&val->maxSamplerAllocationCount);
+    size += vn_sizeof_VkDeviceSize(&val->bufferImageGranularity);
+    size += vn_sizeof_VkDeviceSize(&val->sparseAddressSpaceSize);
+    size += vn_sizeof_uint32_t(&val->maxBoundDescriptorSets);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorSamplers);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUniformBuffers);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorStorageBuffers);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorSampledImages);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorStorageImages);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInputAttachments);
+    size += vn_sizeof_uint32_t(&val->maxPerStageResources);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetSamplers);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUniformBuffers);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUniformBuffersDynamic);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageBuffers);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageBuffersDynamic);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetSampledImages);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageImages);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetInputAttachments);
+    size += vn_sizeof_uint32_t(&val->maxVertexInputAttributes);
+    size += vn_sizeof_uint32_t(&val->maxVertexInputBindings);
+    size += vn_sizeof_uint32_t(&val->maxVertexInputAttributeOffset);
+    size += vn_sizeof_uint32_t(&val->maxVertexInputBindingStride);
+    size += vn_sizeof_uint32_t(&val->maxVertexOutputComponents);
+    size += vn_sizeof_uint32_t(&val->maxTessellationGenerationLevel);
+    size += vn_sizeof_uint32_t(&val->maxTessellationPatchSize);
+    size += vn_sizeof_uint32_t(&val->maxTessellationControlPerVertexInputComponents);
+    size += vn_sizeof_uint32_t(&val->maxTessellationControlPerVertexOutputComponents);
+    size += vn_sizeof_uint32_t(&val->maxTessellationControlPerPatchOutputComponents);
+    size += vn_sizeof_uint32_t(&val->maxTessellationControlTotalOutputComponents);
+    size += vn_sizeof_uint32_t(&val->maxTessellationEvaluationInputComponents);
+    size += vn_sizeof_uint32_t(&val->maxTessellationEvaluationOutputComponents);
+    size += vn_sizeof_uint32_t(&val->maxGeometryShaderInvocations);
+    size += vn_sizeof_uint32_t(&val->maxGeometryInputComponents);
+    size += vn_sizeof_uint32_t(&val->maxGeometryOutputComponents);
+    size += vn_sizeof_uint32_t(&val->maxGeometryOutputVertices);
+    size += vn_sizeof_uint32_t(&val->maxGeometryTotalOutputComponents);
+    size += vn_sizeof_uint32_t(&val->maxFragmentInputComponents);
+    size += vn_sizeof_uint32_t(&val->maxFragmentOutputAttachments);
+    size += vn_sizeof_uint32_t(&val->maxFragmentDualSrcAttachments);
+    size += vn_sizeof_uint32_t(&val->maxFragmentCombinedOutputResources);
+    size += vn_sizeof_uint32_t(&val->maxComputeSharedMemorySize);
+    size += vn_sizeof_array_size(3);
+    size += vn_sizeof_uint32_t_array(val->maxComputeWorkGroupCount, 3);
+    size += vn_sizeof_uint32_t(&val->maxComputeWorkGroupInvocations);
+    size += vn_sizeof_array_size(3);
+    size += vn_sizeof_uint32_t_array(val->maxComputeWorkGroupSize, 3);
+    size += vn_sizeof_uint32_t(&val->subPixelPrecisionBits);
+    size += vn_sizeof_uint32_t(&val->subTexelPrecisionBits);
+    size += vn_sizeof_uint32_t(&val->mipmapPrecisionBits);
+    size += vn_sizeof_uint32_t(&val->maxDrawIndexedIndexValue);
+    size += vn_sizeof_uint32_t(&val->maxDrawIndirectCount);
+    size += vn_sizeof_float(&val->maxSamplerLodBias);
+    size += vn_sizeof_float(&val->maxSamplerAnisotropy);
+    size += vn_sizeof_uint32_t(&val->maxViewports);
+    size += vn_sizeof_array_size(2);
+    size += vn_sizeof_uint32_t_array(val->maxViewportDimensions, 2);
+    size += vn_sizeof_array_size(2);
+    size += vn_sizeof_float_array(val->viewportBoundsRange, 2);
+    size += vn_sizeof_uint32_t(&val->viewportSubPixelBits);
+    size += vn_sizeof_size_t(&val->minMemoryMapAlignment);
+    size += vn_sizeof_VkDeviceSize(&val->minTexelBufferOffsetAlignment);
+    size += vn_sizeof_VkDeviceSize(&val->minUniformBufferOffsetAlignment);
+    size += vn_sizeof_VkDeviceSize(&val->minStorageBufferOffsetAlignment);
+    size += vn_sizeof_int32_t(&val->minTexelOffset);
+    size += vn_sizeof_uint32_t(&val->maxTexelOffset);
+    size += vn_sizeof_int32_t(&val->minTexelGatherOffset);
+    size += vn_sizeof_uint32_t(&val->maxTexelGatherOffset);
+    size += vn_sizeof_float(&val->minInterpolationOffset);
+    size += vn_sizeof_float(&val->maxInterpolationOffset);
+    size += vn_sizeof_uint32_t(&val->subPixelInterpolationOffsetBits);
+    size += vn_sizeof_uint32_t(&val->maxFramebufferWidth);
+    size += vn_sizeof_uint32_t(&val->maxFramebufferHeight);
+    size += vn_sizeof_uint32_t(&val->maxFramebufferLayers);
+    size += vn_sizeof_VkFlags(&val->framebufferColorSampleCounts);
+    size += vn_sizeof_VkFlags(&val->framebufferDepthSampleCounts);
+    size += vn_sizeof_VkFlags(&val->framebufferStencilSampleCounts);
+    size += vn_sizeof_VkFlags(&val->framebufferNoAttachmentsSampleCounts);
+    size += vn_sizeof_uint32_t(&val->maxColorAttachments);
+    size += vn_sizeof_VkFlags(&val->sampledImageColorSampleCounts);
+    size += vn_sizeof_VkFlags(&val->sampledImageIntegerSampleCounts);
+    size += vn_sizeof_VkFlags(&val->sampledImageDepthSampleCounts);
+    size += vn_sizeof_VkFlags(&val->sampledImageStencilSampleCounts);
+    size += vn_sizeof_VkFlags(&val->storageImageSampleCounts);
+    size += vn_sizeof_uint32_t(&val->maxSampleMaskWords);
+    size += vn_sizeof_VkBool32(&val->timestampComputeAndGraphics);
+    size += vn_sizeof_float(&val->timestampPeriod);
+    size += vn_sizeof_uint32_t(&val->maxClipDistances);
+    size += vn_sizeof_uint32_t(&val->maxCullDistances);
+    size += vn_sizeof_uint32_t(&val->maxCombinedClipAndCullDistances);
+    size += vn_sizeof_uint32_t(&val->discreteQueuePriorities);
+    size += vn_sizeof_array_size(2);
+    size += vn_sizeof_float_array(val->pointSizeRange, 2);
+    size += vn_sizeof_array_size(2);
+    size += vn_sizeof_float_array(val->lineWidthRange, 2);
+    size += vn_sizeof_float(&val->pointSizeGranularity);
+    size += vn_sizeof_float(&val->lineWidthGranularity);
+    size += vn_sizeof_VkBool32(&val->strictLines);
+    size += vn_sizeof_VkBool32(&val->standardSampleLocations);
+    size += vn_sizeof_VkDeviceSize(&val->optimalBufferCopyOffsetAlignment);
+    size += vn_sizeof_VkDeviceSize(&val->optimalBufferCopyRowPitchAlignment);
+    size += vn_sizeof_VkDeviceSize(&val->nonCoherentAtomSize);
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceLimits(struct vn_cs_decoder *dec, VkPhysicalDeviceLimits *val)
+{
+    vn_decode_uint32_t(dec, &val->maxImageDimension1D);
+    vn_decode_uint32_t(dec, &val->maxImageDimension2D);
+    vn_decode_uint32_t(dec, &val->maxImageDimension3D);
+    vn_decode_uint32_t(dec, &val->maxImageDimensionCube);
+    vn_decode_uint32_t(dec, &val->maxImageArrayLayers);
+    vn_decode_uint32_t(dec, &val->maxTexelBufferElements);
+    vn_decode_uint32_t(dec, &val->maxUniformBufferRange);
+    vn_decode_uint32_t(dec, &val->maxStorageBufferRange);
+    vn_decode_uint32_t(dec, &val->maxPushConstantsSize);
+    vn_decode_uint32_t(dec, &val->maxMemoryAllocationCount);
+    vn_decode_uint32_t(dec, &val->maxSamplerAllocationCount);
+    vn_decode_VkDeviceSize(dec, &val->bufferImageGranularity);
+    vn_decode_VkDeviceSize(dec, &val->sparseAddressSpaceSize);
+    vn_decode_uint32_t(dec, &val->maxBoundDescriptorSets);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorSamplers);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUniformBuffers);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorStorageBuffers);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorSampledImages);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorStorageImages);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInputAttachments);
+    vn_decode_uint32_t(dec, &val->maxPerStageResources);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetSamplers);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUniformBuffers);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUniformBuffersDynamic);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageBuffers);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageBuffersDynamic);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetSampledImages);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageImages);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetInputAttachments);
+    vn_decode_uint32_t(dec, &val->maxVertexInputAttributes);
+    vn_decode_uint32_t(dec, &val->maxVertexInputBindings);
+    vn_decode_uint32_t(dec, &val->maxVertexInputAttributeOffset);
+    vn_decode_uint32_t(dec, &val->maxVertexInputBindingStride);
+    vn_decode_uint32_t(dec, &val->maxVertexOutputComponents);
+    vn_decode_uint32_t(dec, &val->maxTessellationGenerationLevel);
+    vn_decode_uint32_t(dec, &val->maxTessellationPatchSize);
+    vn_decode_uint32_t(dec, &val->maxTessellationControlPerVertexInputComponents);
+    vn_decode_uint32_t(dec, &val->maxTessellationControlPerVertexOutputComponents);
+    vn_decode_uint32_t(dec, &val->maxTessellationControlPerPatchOutputComponents);
+    vn_decode_uint32_t(dec, &val->maxTessellationControlTotalOutputComponents);
+    vn_decode_uint32_t(dec, &val->maxTessellationEvaluationInputComponents);
+    vn_decode_uint32_t(dec, &val->maxTessellationEvaluationOutputComponents);
+    vn_decode_uint32_t(dec, &val->maxGeometryShaderInvocations);
+    vn_decode_uint32_t(dec, &val->maxGeometryInputComponents);
+    vn_decode_uint32_t(dec, &val->maxGeometryOutputComponents);
+    vn_decode_uint32_t(dec, &val->maxGeometryOutputVertices);
+    vn_decode_uint32_t(dec, &val->maxGeometryTotalOutputComponents);
+    vn_decode_uint32_t(dec, &val->maxFragmentInputComponents);
+    vn_decode_uint32_t(dec, &val->maxFragmentOutputAttachments);
+    vn_decode_uint32_t(dec, &val->maxFragmentDualSrcAttachments);
+    vn_decode_uint32_t(dec, &val->maxFragmentCombinedOutputResources);
+    vn_decode_uint32_t(dec, &val->maxComputeSharedMemorySize);
+    {
+        const size_t array_size = vn_decode_array_size(dec, 3);
+        vn_decode_uint32_t_array(dec, val->maxComputeWorkGroupCount, array_size);
+    }
+    vn_decode_uint32_t(dec, &val->maxComputeWorkGroupInvocations);
+    {
+        const size_t array_size = vn_decode_array_size(dec, 3);
+        vn_decode_uint32_t_array(dec, val->maxComputeWorkGroupSize, array_size);
+    }
+    vn_decode_uint32_t(dec, &val->subPixelPrecisionBits);
+    vn_decode_uint32_t(dec, &val->subTexelPrecisionBits);
+    vn_decode_uint32_t(dec, &val->mipmapPrecisionBits);
+    vn_decode_uint32_t(dec, &val->maxDrawIndexedIndexValue);
+    vn_decode_uint32_t(dec, &val->maxDrawIndirectCount);
+    vn_decode_float(dec, &val->maxSamplerLodBias);
+    vn_decode_float(dec, &val->maxSamplerAnisotropy);
+    vn_decode_uint32_t(dec, &val->maxViewports);
+    {
+        const size_t array_size = vn_decode_array_size(dec, 2);
+        vn_decode_uint32_t_array(dec, val->maxViewportDimensions, array_size);
+    }
+    {
+        const size_t array_size = vn_decode_array_size(dec, 2);
+        vn_decode_float_array(dec, val->viewportBoundsRange, array_size);
+    }
+    vn_decode_uint32_t(dec, &val->viewportSubPixelBits);
+    vn_decode_size_t(dec, &val->minMemoryMapAlignment);
+    vn_decode_VkDeviceSize(dec, &val->minTexelBufferOffsetAlignment);
+    vn_decode_VkDeviceSize(dec, &val->minUniformBufferOffsetAlignment);
+    vn_decode_VkDeviceSize(dec, &val->minStorageBufferOffsetAlignment);
+    vn_decode_int32_t(dec, &val->minTexelOffset);
+    vn_decode_uint32_t(dec, &val->maxTexelOffset);
+    vn_decode_int32_t(dec, &val->minTexelGatherOffset);
+    vn_decode_uint32_t(dec, &val->maxTexelGatherOffset);
+    vn_decode_float(dec, &val->minInterpolationOffset);
+    vn_decode_float(dec, &val->maxInterpolationOffset);
+    vn_decode_uint32_t(dec, &val->subPixelInterpolationOffsetBits);
+    vn_decode_uint32_t(dec, &val->maxFramebufferWidth);
+    vn_decode_uint32_t(dec, &val->maxFramebufferHeight);
+    vn_decode_uint32_t(dec, &val->maxFramebufferLayers);
+    vn_decode_VkFlags(dec, &val->framebufferColorSampleCounts);
+    vn_decode_VkFlags(dec, &val->framebufferDepthSampleCounts);
+    vn_decode_VkFlags(dec, &val->framebufferStencilSampleCounts);
+    vn_decode_VkFlags(dec, &val->framebufferNoAttachmentsSampleCounts);
+    vn_decode_uint32_t(dec, &val->maxColorAttachments);
+    vn_decode_VkFlags(dec, &val->sampledImageColorSampleCounts);
+    vn_decode_VkFlags(dec, &val->sampledImageIntegerSampleCounts);
+    vn_decode_VkFlags(dec, &val->sampledImageDepthSampleCounts);
+    vn_decode_VkFlags(dec, &val->sampledImageStencilSampleCounts);
+    vn_decode_VkFlags(dec, &val->storageImageSampleCounts);
+    vn_decode_uint32_t(dec, &val->maxSampleMaskWords);
+    vn_decode_VkBool32(dec, &val->timestampComputeAndGraphics);
+    vn_decode_float(dec, &val->timestampPeriod);
+    vn_decode_uint32_t(dec, &val->maxClipDistances);
+    vn_decode_uint32_t(dec, &val->maxCullDistances);
+    vn_decode_uint32_t(dec, &val->maxCombinedClipAndCullDistances);
+    vn_decode_uint32_t(dec, &val->discreteQueuePriorities);
+    {
+        const size_t array_size = vn_decode_array_size(dec, 2);
+        vn_decode_float_array(dec, val->pointSizeRange, array_size);
+    }
+    {
+        const size_t array_size = vn_decode_array_size(dec, 2);
+        vn_decode_float_array(dec, val->lineWidthRange, array_size);
+    }
+    vn_decode_float(dec, &val->pointSizeGranularity);
+    vn_decode_float(dec, &val->lineWidthGranularity);
+    vn_decode_VkBool32(dec, &val->strictLines);
+    vn_decode_VkBool32(dec, &val->standardSampleLocations);
+    vn_decode_VkDeviceSize(dec, &val->optimalBufferCopyOffsetAlignment);
+    vn_decode_VkDeviceSize(dec, &val->optimalBufferCopyRowPitchAlignment);
+    vn_decode_VkDeviceSize(dec, &val->nonCoherentAtomSize);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceLimits_partial(const VkPhysicalDeviceLimits *val)
+{
+    size_t size = 0;
+    /* skip val->maxImageDimension1D */
+    /* skip val->maxImageDimension2D */
+    /* skip val->maxImageDimension3D */
+    /* skip val->maxImageDimensionCube */
+    /* skip val->maxImageArrayLayers */
+    /* skip val->maxTexelBufferElements */
+    /* skip val->maxUniformBufferRange */
+    /* skip val->maxStorageBufferRange */
+    /* skip val->maxPushConstantsSize */
+    /* skip val->maxMemoryAllocationCount */
+    /* skip val->maxSamplerAllocationCount */
+    /* skip val->bufferImageGranularity */
+    /* skip val->sparseAddressSpaceSize */
+    /* skip val->maxBoundDescriptorSets */
+    /* skip val->maxPerStageDescriptorSamplers */
+    /* skip val->maxPerStageDescriptorUniformBuffers */
+    /* skip val->maxPerStageDescriptorStorageBuffers */
+    /* skip val->maxPerStageDescriptorSampledImages */
+    /* skip val->maxPerStageDescriptorStorageImages */
+    /* skip val->maxPerStageDescriptorInputAttachments */
+    /* skip val->maxPerStageResources */
+    /* skip val->maxDescriptorSetSamplers */
+    /* skip val->maxDescriptorSetUniformBuffers */
+    /* skip val->maxDescriptorSetUniformBuffersDynamic */
+    /* skip val->maxDescriptorSetStorageBuffers */
+    /* skip val->maxDescriptorSetStorageBuffersDynamic */
+    /* skip val->maxDescriptorSetSampledImages */
+    /* skip val->maxDescriptorSetStorageImages */
+    /* skip val->maxDescriptorSetInputAttachments */
+    /* skip val->maxVertexInputAttributes */
+    /* skip val->maxVertexInputBindings */
+    /* skip val->maxVertexInputAttributeOffset */
+    /* skip val->maxVertexInputBindingStride */
+    /* skip val->maxVertexOutputComponents */
+    /* skip val->maxTessellationGenerationLevel */
+    /* skip val->maxTessellationPatchSize */
+    /* skip val->maxTessellationControlPerVertexInputComponents */
+    /* skip val->maxTessellationControlPerVertexOutputComponents */
+    /* skip val->maxTessellationControlPerPatchOutputComponents */
+    /* skip val->maxTessellationControlTotalOutputComponents */
+    /* skip val->maxTessellationEvaluationInputComponents */
+    /* skip val->maxTessellationEvaluationOutputComponents */
+    /* skip val->maxGeometryShaderInvocations */
+    /* skip val->maxGeometryInputComponents */
+    /* skip val->maxGeometryOutputComponents */
+    /* skip val->maxGeometryOutputVertices */
+    /* skip val->maxGeometryTotalOutputComponents */
+    /* skip val->maxFragmentInputComponents */
+    /* skip val->maxFragmentOutputAttachments */
+    /* skip val->maxFragmentDualSrcAttachments */
+    /* skip val->maxFragmentCombinedOutputResources */
+    /* skip val->maxComputeSharedMemorySize */
+    /* skip val->maxComputeWorkGroupCount */
+    /* skip val->maxComputeWorkGroupInvocations */
+    /* skip val->maxComputeWorkGroupSize */
+    /* skip val->subPixelPrecisionBits */
+    /* skip val->subTexelPrecisionBits */
+    /* skip val->mipmapPrecisionBits */
+    /* skip val->maxDrawIndexedIndexValue */
+    /* skip val->maxDrawIndirectCount */
+    /* skip val->maxSamplerLodBias */
+    /* skip val->maxSamplerAnisotropy */
+    /* skip val->maxViewports */
+    /* skip val->maxViewportDimensions */
+    /* skip val->viewportBoundsRange */
+    /* skip val->viewportSubPixelBits */
+    /* skip val->minMemoryMapAlignment */
+    /* skip val->minTexelBufferOffsetAlignment */
+    /* skip val->minUniformBufferOffsetAlignment */
+    /* skip val->minStorageBufferOffsetAlignment */
+    /* skip val->minTexelOffset */
+    /* skip val->maxTexelOffset */
+    /* skip val->minTexelGatherOffset */
+    /* skip val->maxTexelGatherOffset */
+    /* skip val->minInterpolationOffset */
+    /* skip val->maxInterpolationOffset */
+    /* skip val->subPixelInterpolationOffsetBits */
+    /* skip val->maxFramebufferWidth */
+    /* skip val->maxFramebufferHeight */
+    /* skip val->maxFramebufferLayers */
+    /* skip val->framebufferColorSampleCounts */
+    /* skip val->framebufferDepthSampleCounts */
+    /* skip val->framebufferStencilSampleCounts */
+    /* skip val->framebufferNoAttachmentsSampleCounts */
+    /* skip val->maxColorAttachments */
+    /* skip val->sampledImageColorSampleCounts */
+    /* skip val->sampledImageIntegerSampleCounts */
+    /* skip val->sampledImageDepthSampleCounts */
+    /* skip val->sampledImageStencilSampleCounts */
+    /* skip val->storageImageSampleCounts */
+    /* skip val->maxSampleMaskWords */
+    /* skip val->timestampComputeAndGraphics */
+    /* skip val->timestampPeriod */
+    /* skip val->maxClipDistances */
+    /* skip val->maxCullDistances */
+    /* skip val->maxCombinedClipAndCullDistances */
+    /* skip val->discreteQueuePriorities */
+    /* skip val->pointSizeRange */
+    /* skip val->lineWidthRange */
+    /* skip val->pointSizeGranularity */
+    /* skip val->lineWidthGranularity */
+    /* skip val->strictLines */
+    /* skip val->standardSampleLocations */
+    /* skip val->optimalBufferCopyOffsetAlignment */
+    /* skip val->optimalBufferCopyRowPitchAlignment */
+    /* skip val->nonCoherentAtomSize */
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceLimits_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLimits *val)
+{
+    /* skip val->maxImageDimension1D */
+    /* skip val->maxImageDimension2D */
+    /* skip val->maxImageDimension3D */
+    /* skip val->maxImageDimensionCube */
+    /* skip val->maxImageArrayLayers */
+    /* skip val->maxTexelBufferElements */
+    /* skip val->maxUniformBufferRange */
+    /* skip val->maxStorageBufferRange */
+    /* skip val->maxPushConstantsSize */
+    /* skip val->maxMemoryAllocationCount */
+    /* skip val->maxSamplerAllocationCount */
+    /* skip val->bufferImageGranularity */
+    /* skip val->sparseAddressSpaceSize */
+    /* skip val->maxBoundDescriptorSets */
+    /* skip val->maxPerStageDescriptorSamplers */
+    /* skip val->maxPerStageDescriptorUniformBuffers */
+    /* skip val->maxPerStageDescriptorStorageBuffers */
+    /* skip val->maxPerStageDescriptorSampledImages */
+    /* skip val->maxPerStageDescriptorStorageImages */
+    /* skip val->maxPerStageDescriptorInputAttachments */
+    /* skip val->maxPerStageResources */
+    /* skip val->maxDescriptorSetSamplers */
+    /* skip val->maxDescriptorSetUniformBuffers */
+    /* skip val->maxDescriptorSetUniformBuffersDynamic */
+    /* skip val->maxDescriptorSetStorageBuffers */
+    /* skip val->maxDescriptorSetStorageBuffersDynamic */
+    /* skip val->maxDescriptorSetSampledImages */
+    /* skip val->maxDescriptorSetStorageImages */
+    /* skip val->maxDescriptorSetInputAttachments */
+    /* skip val->maxVertexInputAttributes */
+    /* skip val->maxVertexInputBindings */
+    /* skip val->maxVertexInputAttributeOffset */
+    /* skip val->maxVertexInputBindingStride */
+    /* skip val->maxVertexOutputComponents */
+    /* skip val->maxTessellationGenerationLevel */
+    /* skip val->maxTessellationPatchSize */
+    /* skip val->maxTessellationControlPerVertexInputComponents */
+    /* skip val->maxTessellationControlPerVertexOutputComponents */
+    /* skip val->maxTessellationControlPerPatchOutputComponents */
+    /* skip val->maxTessellationControlTotalOutputComponents */
+    /* skip val->maxTessellationEvaluationInputComponents */
+    /* skip val->maxTessellationEvaluationOutputComponents */
+    /* skip val->maxGeometryShaderInvocations */
+    /* skip val->maxGeometryInputComponents */
+    /* skip val->maxGeometryOutputComponents */
+    /* skip val->maxGeometryOutputVertices */
+    /* skip val->maxGeometryTotalOutputComponents */
+    /* skip val->maxFragmentInputComponents */
+    /* skip val->maxFragmentOutputAttachments */
+    /* skip val->maxFragmentDualSrcAttachments */
+    /* skip val->maxFragmentCombinedOutputResources */
+    /* skip val->maxComputeSharedMemorySize */
+    /* skip val->maxComputeWorkGroupCount */
+    /* skip val->maxComputeWorkGroupInvocations */
+    /* skip val->maxComputeWorkGroupSize */
+    /* skip val->subPixelPrecisionBits */
+    /* skip val->subTexelPrecisionBits */
+    /* skip val->mipmapPrecisionBits */
+    /* skip val->maxDrawIndexedIndexValue */
+    /* skip val->maxDrawIndirectCount */
+    /* skip val->maxSamplerLodBias */
+    /* skip val->maxSamplerAnisotropy */
+    /* skip val->maxViewports */
+    /* skip val->maxViewportDimensions */
+    /* skip val->viewportBoundsRange */
+    /* skip val->viewportSubPixelBits */
+    /* skip val->minMemoryMapAlignment */
+    /* skip val->minTexelBufferOffsetAlignment */
+    /* skip val->minUniformBufferOffsetAlignment */
+    /* skip val->minStorageBufferOffsetAlignment */
+    /* skip val->minTexelOffset */
+    /* skip val->maxTexelOffset */
+    /* skip val->minTexelGatherOffset */
+    /* skip val->maxTexelGatherOffset */
+    /* skip val->minInterpolationOffset */
+    /* skip val->maxInterpolationOffset */
+    /* skip val->subPixelInterpolationOffsetBits */
+    /* skip val->maxFramebufferWidth */
+    /* skip val->maxFramebufferHeight */
+    /* skip val->maxFramebufferLayers */
+    /* skip val->framebufferColorSampleCounts */
+    /* skip val->framebufferDepthSampleCounts */
+    /* skip val->framebufferStencilSampleCounts */
+    /* skip val->framebufferNoAttachmentsSampleCounts */
+    /* skip val->maxColorAttachments */
+    /* skip val->sampledImageColorSampleCounts */
+    /* skip val->sampledImageIntegerSampleCounts */
+    /* skip val->sampledImageDepthSampleCounts */
+    /* skip val->sampledImageStencilSampleCounts */
+    /* skip val->storageImageSampleCounts */
+    /* skip val->maxSampleMaskWords */
+    /* skip val->timestampComputeAndGraphics */
+    /* skip val->timestampPeriod */
+    /* skip val->maxClipDistances */
+    /* skip val->maxCullDistances */
+    /* skip val->maxCombinedClipAndCullDistances */
+    /* skip val->discreteQueuePriorities */
+    /* skip val->pointSizeRange */
+    /* skip val->lineWidthRange */
+    /* skip val->pointSizeGranularity */
+    /* skip val->lineWidthGranularity */
+    /* skip val->strictLines */
+    /* skip val->standardSampleLocations */
+    /* skip val->optimalBufferCopyOffsetAlignment */
+    /* skip val->optimalBufferCopyRowPitchAlignment */
+    /* skip val->nonCoherentAtomSize */
+}
+
+/* struct VkPhysicalDeviceSparseProperties */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkBool32(&val->residencyStandard2DBlockShape);
+    size += vn_sizeof_VkBool32(&val->residencyStandard2DMultisampleBlockShape);
+    size += vn_sizeof_VkBool32(&val->residencyStandard3DBlockShape);
+    size += vn_sizeof_VkBool32(&val->residencyAlignedMipSize);
+    size += vn_sizeof_VkBool32(&val->residencyNonResidentStrict);
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSparseProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSparseProperties *val)
+{
+    vn_decode_VkBool32(dec, &val->residencyStandard2DBlockShape);
+    vn_decode_VkBool32(dec, &val->residencyStandard2DMultisampleBlockShape);
+    vn_decode_VkBool32(dec, &val->residencyStandard3DBlockShape);
+    vn_decode_VkBool32(dec, &val->residencyAlignedMipSize);
+    vn_decode_VkBool32(dec, &val->residencyNonResidentStrict);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSparseProperties_partial(const VkPhysicalDeviceSparseProperties *val)
+{
+    size_t size = 0;
+    /* skip val->residencyStandard2DBlockShape */
+    /* skip val->residencyStandard2DMultisampleBlockShape */
+    /* skip val->residencyStandard3DBlockShape */
+    /* skip val->residencyAlignedMipSize */
+    /* skip val->residencyNonResidentStrict */
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSparseProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseProperties *val)
+{
+    /* skip val->residencyStandard2DBlockShape */
+    /* skip val->residencyStandard2DMultisampleBlockShape */
+    /* skip val->residencyStandard3DBlockShape */
+    /* skip val->residencyAlignedMipSize */
+    /* skip val->residencyNonResidentStrict */
+}
+
+/* struct VkPhysicalDeviceProperties */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->apiVersion);
+    size += vn_sizeof_uint32_t(&val->driverVersion);
+    size += vn_sizeof_uint32_t(&val->vendorID);
+    size += vn_sizeof_uint32_t(&val->deviceID);
+    size += vn_sizeof_VkPhysicalDeviceType(&val->deviceType);
+    size += vn_sizeof_array_size(VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
+    size += vn_sizeof_blob_array(val->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
+    size += vn_sizeof_array_size(VK_UUID_SIZE);
+    size += vn_sizeof_uint8_t_array(val->pipelineCacheUUID, VK_UUID_SIZE);
+    size += vn_sizeof_VkPhysicalDeviceLimits(&val->limits);
+    size += vn_sizeof_VkPhysicalDeviceSparseProperties(&val->sparseProperties);
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties *val)
+{
+    vn_decode_uint32_t(dec, &val->apiVersion);
+    vn_decode_uint32_t(dec, &val->driverVersion);
+    vn_decode_uint32_t(dec, &val->vendorID);
+    vn_decode_uint32_t(dec, &val->deviceID);
+    vn_decode_VkPhysicalDeviceType(dec, &val->deviceType);
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
+        vn_decode_blob_array(dec, val->deviceName, array_size);
+    }
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
+        vn_decode_uint8_t_array(dec, val->pipelineCacheUUID, array_size);
+    }
+    vn_decode_VkPhysicalDeviceLimits(dec, &val->limits);
+    vn_decode_VkPhysicalDeviceSparseProperties(dec, &val->sparseProperties);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProperties_partial(const VkPhysicalDeviceProperties *val)
+{
+    size_t size = 0;
+    /* skip val->apiVersion */
+    /* skip val->driverVersion */
+    /* skip val->vendorID */
+    /* skip val->deviceID */
+    /* skip val->deviceType */
+    /* skip val->deviceName */
+    /* skip val->pipelineCacheUUID */
+    size += vn_sizeof_VkPhysicalDeviceLimits_partial(&val->limits);
+    size += vn_sizeof_VkPhysicalDeviceSparseProperties_partial(&val->sparseProperties);
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties *val)
+{
+    /* skip val->apiVersion */
+    /* skip val->driverVersion */
+    /* skip val->vendorID */
+    /* skip val->deviceID */
+    /* skip val->deviceType */
+    /* skip val->deviceName */
+    /* skip val->pipelineCacheUUID */
+    vn_encode_VkPhysicalDeviceLimits_partial(enc, &val->limits);
+    vn_encode_VkPhysicalDeviceSparseProperties_partial(enc, &val->sparseProperties);
+}
+
+/* struct VkQueueFamilyProperties */
+
+static inline size_t
+vn_sizeof_VkQueueFamilyProperties(const VkQueueFamilyProperties *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->queueFlags);
+    size += vn_sizeof_uint32_t(&val->queueCount);
+    size += vn_sizeof_uint32_t(&val->timestampValidBits);
+    size += vn_sizeof_VkExtent3D(&val->minImageTransferGranularity);
+    return size;
+}
+
+static inline void
+vn_decode_VkQueueFamilyProperties(struct vn_cs_decoder *dec, VkQueueFamilyProperties *val)
+{
+    vn_decode_VkFlags(dec, &val->queueFlags);
+    vn_decode_uint32_t(dec, &val->queueCount);
+    vn_decode_uint32_t(dec, &val->timestampValidBits);
+    vn_decode_VkExtent3D(dec, &val->minImageTransferGranularity);
+}
+
+static inline size_t
+vn_sizeof_VkQueueFamilyProperties_partial(const VkQueueFamilyProperties *val)
+{
+    size_t size = 0;
+    /* skip val->queueFlags */
+    /* skip val->queueCount */
+    /* skip val->timestampValidBits */
+    size += vn_sizeof_VkExtent3D_partial(&val->minImageTransferGranularity);
+    return size;
+}
+
+static inline void
+vn_encode_VkQueueFamilyProperties_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties *val)
+{
+    /* skip val->queueFlags */
+    /* skip val->queueCount */
+    /* skip val->timestampValidBits */
+    vn_encode_VkExtent3D_partial(enc, &val->minImageTransferGranularity);
+}
+
+/* struct VkMemoryType */
+
+static inline size_t
+vn_sizeof_VkMemoryType(const VkMemoryType *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->propertyFlags);
+    size += vn_sizeof_uint32_t(&val->heapIndex);
+    return size;
+}
+
+static inline void
+vn_decode_VkMemoryType(struct vn_cs_decoder *dec, VkMemoryType *val)
+{
+    vn_decode_VkFlags(dec, &val->propertyFlags);
+    vn_decode_uint32_t(dec, &val->heapIndex);
+}
+
+static inline size_t
+vn_sizeof_VkMemoryType_partial(const VkMemoryType *val)
+{
+    size_t size = 0;
+    /* skip val->propertyFlags */
+    /* skip val->heapIndex */
+    return size;
+}
+
+static inline void
+vn_encode_VkMemoryType_partial(struct vn_cs_encoder *enc, const VkMemoryType *val)
+{
+    /* skip val->propertyFlags */
+    /* skip val->heapIndex */
+}
+
+/* struct VkMemoryHeap */
+
+static inline size_t
+vn_sizeof_VkMemoryHeap(const VkMemoryHeap *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkDeviceSize(&val->size);
+    size += vn_sizeof_VkFlags(&val->flags);
+    return size;
+}
+
+static inline void
+vn_decode_VkMemoryHeap(struct vn_cs_decoder *dec, VkMemoryHeap *val)
+{
+    vn_decode_VkDeviceSize(dec, &val->size);
+    vn_decode_VkFlags(dec, &val->flags);
+}
+
+static inline size_t
+vn_sizeof_VkMemoryHeap_partial(const VkMemoryHeap *val)
+{
+    size_t size = 0;
+    /* skip val->size */
+    /* skip val->flags */
+    return size;
+}
+
+static inline void
+vn_encode_VkMemoryHeap_partial(struct vn_cs_encoder *enc, const VkMemoryHeap *val)
+{
+    /* skip val->size */
+    /* skip val->flags */
+}
+
+/* struct VkPhysicalDeviceMemoryProperties */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->memoryTypeCount);
+    size += vn_sizeof_array_size(VK_MAX_MEMORY_TYPES);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
+        size += vn_sizeof_VkMemoryType(&val->memoryTypes[i]);
+    size += vn_sizeof_uint32_t(&val->memoryHeapCount);
+    size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
+        size += vn_sizeof_VkMemoryHeap(&val->memoryHeaps[i]);
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties *val)
+{
+    vn_decode_uint32_t(dec, &val->memoryTypeCount);
+    {
+        vn_decode_array_size(dec, VK_MAX_MEMORY_TYPES);
+        for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
+            vn_decode_VkMemoryType(dec, &val->memoryTypes[i]);
+    }
+    vn_decode_uint32_t(dec, &val->memoryHeapCount);
+    {
+        vn_decode_array_size(dec, VK_MAX_MEMORY_HEAPS);
+        for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
+            vn_decode_VkMemoryHeap(dec, &val->memoryHeaps[i]);
+    }
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(const VkPhysicalDeviceMemoryProperties *val)
+{
+    size_t size = 0;
+    /* skip val->memoryTypeCount */
+    size += vn_sizeof_array_size(VK_MAX_MEMORY_TYPES);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
+        size += vn_sizeof_VkMemoryType_partial(&val->memoryTypes[i]);
+    /* skip val->memoryHeapCount */
+    size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
+        size += vn_sizeof_VkMemoryHeap_partial(&val->memoryHeaps[i]);
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties *val)
+{
+    /* skip val->memoryTypeCount */
+    vn_encode_array_size(enc, VK_MAX_MEMORY_TYPES);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
+        vn_encode_VkMemoryType_partial(enc, &val->memoryTypes[i]);
+    /* skip val->memoryHeapCount */
+    vn_encode_array_size(enc, VK_MAX_MEMORY_HEAPS);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
+        vn_encode_VkMemoryHeap_partial(enc, &val->memoryHeaps[i]);
+}
+
+/* struct VkPhysicalDeviceFeatures */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkBool32(&val->robustBufferAccess);
+    size += vn_sizeof_VkBool32(&val->fullDrawIndexUint32);
+    size += vn_sizeof_VkBool32(&val->imageCubeArray);
+    size += vn_sizeof_VkBool32(&val->independentBlend);
+    size += vn_sizeof_VkBool32(&val->geometryShader);
+    size += vn_sizeof_VkBool32(&val->tessellationShader);
+    size += vn_sizeof_VkBool32(&val->sampleRateShading);
+    size += vn_sizeof_VkBool32(&val->dualSrcBlend);
+    size += vn_sizeof_VkBool32(&val->logicOp);
+    size += vn_sizeof_VkBool32(&val->multiDrawIndirect);
+    size += vn_sizeof_VkBool32(&val->drawIndirectFirstInstance);
+    size += vn_sizeof_VkBool32(&val->depthClamp);
+    size += vn_sizeof_VkBool32(&val->depthBiasClamp);
+    size += vn_sizeof_VkBool32(&val->fillModeNonSolid);
+    size += vn_sizeof_VkBool32(&val->depthBounds);
+    size += vn_sizeof_VkBool32(&val->wideLines);
+    size += vn_sizeof_VkBool32(&val->largePoints);
+    size += vn_sizeof_VkBool32(&val->alphaToOne);
+    size += vn_sizeof_VkBool32(&val->multiViewport);
+    size += vn_sizeof_VkBool32(&val->samplerAnisotropy);
+    size += vn_sizeof_VkBool32(&val->textureCompressionETC2);
+    size += vn_sizeof_VkBool32(&val->textureCompressionASTC_LDR);
+    size += vn_sizeof_VkBool32(&val->textureCompressionBC);
+    size += vn_sizeof_VkBool32(&val->occlusionQueryPrecise);
+    size += vn_sizeof_VkBool32(&val->pipelineStatisticsQuery);
+    size += vn_sizeof_VkBool32(&val->vertexPipelineStoresAndAtomics);
+    size += vn_sizeof_VkBool32(&val->fragmentStoresAndAtomics);
+    size += vn_sizeof_VkBool32(&val->shaderTessellationAndGeometryPointSize);
+    size += vn_sizeof_VkBool32(&val->shaderImageGatherExtended);
+    size += vn_sizeof_VkBool32(&val->shaderStorageImageExtendedFormats);
+    size += vn_sizeof_VkBool32(&val->shaderStorageImageMultisample);
+    size += vn_sizeof_VkBool32(&val->shaderStorageImageReadWithoutFormat);
+    size += vn_sizeof_VkBool32(&val->shaderStorageImageWriteWithoutFormat);
+    size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayDynamicIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayDynamicIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayDynamicIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayDynamicIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderClipDistance);
+    size += vn_sizeof_VkBool32(&val->shaderCullDistance);
+    size += vn_sizeof_VkBool32(&val->shaderFloat64);
+    size += vn_sizeof_VkBool32(&val->shaderInt64);
+    size += vn_sizeof_VkBool32(&val->shaderInt16);
+    size += vn_sizeof_VkBool32(&val->shaderResourceResidency);
+    size += vn_sizeof_VkBool32(&val->shaderResourceMinLod);
+    size += vn_sizeof_VkBool32(&val->sparseBinding);
+    size += vn_sizeof_VkBool32(&val->sparseResidencyBuffer);
+    size += vn_sizeof_VkBool32(&val->sparseResidencyImage2D);
+    size += vn_sizeof_VkBool32(&val->sparseResidencyImage3D);
+    size += vn_sizeof_VkBool32(&val->sparseResidency2Samples);
+    size += vn_sizeof_VkBool32(&val->sparseResidency4Samples);
+    size += vn_sizeof_VkBool32(&val->sparseResidency8Samples);
+    size += vn_sizeof_VkBool32(&val->sparseResidency16Samples);
+    size += vn_sizeof_VkBool32(&val->sparseResidencyAliased);
+    size += vn_sizeof_VkBool32(&val->variableMultisampleRate);
+    size += vn_sizeof_VkBool32(&val->inheritedQueries);
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val)
+{
+    vn_encode_VkBool32(enc, &val->robustBufferAccess);
+    vn_encode_VkBool32(enc, &val->fullDrawIndexUint32);
+    vn_encode_VkBool32(enc, &val->imageCubeArray);
+    vn_encode_VkBool32(enc, &val->independentBlend);
+    vn_encode_VkBool32(enc, &val->geometryShader);
+    vn_encode_VkBool32(enc, &val->tessellationShader);
+    vn_encode_VkBool32(enc, &val->sampleRateShading);
+    vn_encode_VkBool32(enc, &val->dualSrcBlend);
+    vn_encode_VkBool32(enc, &val->logicOp);
+    vn_encode_VkBool32(enc, &val->multiDrawIndirect);
+    vn_encode_VkBool32(enc, &val->drawIndirectFirstInstance);
+    vn_encode_VkBool32(enc, &val->depthClamp);
+    vn_encode_VkBool32(enc, &val->depthBiasClamp);
+    vn_encode_VkBool32(enc, &val->fillModeNonSolid);
+    vn_encode_VkBool32(enc, &val->depthBounds);
+    vn_encode_VkBool32(enc, &val->wideLines);
+    vn_encode_VkBool32(enc, &val->largePoints);
+    vn_encode_VkBool32(enc, &val->alphaToOne);
+    vn_encode_VkBool32(enc, &val->multiViewport);
+    vn_encode_VkBool32(enc, &val->samplerAnisotropy);
+    vn_encode_VkBool32(enc, &val->textureCompressionETC2);
+    vn_encode_VkBool32(enc, &val->textureCompressionASTC_LDR);
+    vn_encode_VkBool32(enc, &val->textureCompressionBC);
+    vn_encode_VkBool32(enc, &val->occlusionQueryPrecise);
+    vn_encode_VkBool32(enc, &val->pipelineStatisticsQuery);
+    vn_encode_VkBool32(enc, &val->vertexPipelineStoresAndAtomics);
+    vn_encode_VkBool32(enc, &val->fragmentStoresAndAtomics);
+    vn_encode_VkBool32(enc, &val->shaderTessellationAndGeometryPointSize);
+    vn_encode_VkBool32(enc, &val->shaderImageGatherExtended);
+    vn_encode_VkBool32(enc, &val->shaderStorageImageExtendedFormats);
+    vn_encode_VkBool32(enc, &val->shaderStorageImageMultisample);
+    vn_encode_VkBool32(enc, &val->shaderStorageImageReadWithoutFormat);
+    vn_encode_VkBool32(enc, &val->shaderStorageImageWriteWithoutFormat);
+    vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayDynamicIndexing);
+    vn_encode_VkBool32(enc, &val->shaderSampledImageArrayDynamicIndexing);
+    vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayDynamicIndexing);
+    vn_encode_VkBool32(enc, &val->shaderStorageImageArrayDynamicIndexing);
+    vn_encode_VkBool32(enc, &val->shaderClipDistance);
+    vn_encode_VkBool32(enc, &val->shaderCullDistance);
+    vn_encode_VkBool32(enc, &val->shaderFloat64);
+    vn_encode_VkBool32(enc, &val->shaderInt64);
+    vn_encode_VkBool32(enc, &val->shaderInt16);
+    vn_encode_VkBool32(enc, &val->shaderResourceResidency);
+    vn_encode_VkBool32(enc, &val->shaderResourceMinLod);
+    vn_encode_VkBool32(enc, &val->sparseBinding);
+    vn_encode_VkBool32(enc, &val->sparseResidencyBuffer);
+    vn_encode_VkBool32(enc, &val->sparseResidencyImage2D);
+    vn_encode_VkBool32(enc, &val->sparseResidencyImage3D);
+    vn_encode_VkBool32(enc, &val->sparseResidency2Samples);
+    vn_encode_VkBool32(enc, &val->sparseResidency4Samples);
+    vn_encode_VkBool32(enc, &val->sparseResidency8Samples);
+    vn_encode_VkBool32(enc, &val->sparseResidency16Samples);
+    vn_encode_VkBool32(enc, &val->sparseResidencyAliased);
+    vn_encode_VkBool32(enc, &val->variableMultisampleRate);
+    vn_encode_VkBool32(enc, &val->inheritedQueries);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures *val)
+{
+    vn_decode_VkBool32(dec, &val->robustBufferAccess);
+    vn_decode_VkBool32(dec, &val->fullDrawIndexUint32);
+    vn_decode_VkBool32(dec, &val->imageCubeArray);
+    vn_decode_VkBool32(dec, &val->independentBlend);
+    vn_decode_VkBool32(dec, &val->geometryShader);
+    vn_decode_VkBool32(dec, &val->tessellationShader);
+    vn_decode_VkBool32(dec, &val->sampleRateShading);
+    vn_decode_VkBool32(dec, &val->dualSrcBlend);
+    vn_decode_VkBool32(dec, &val->logicOp);
+    vn_decode_VkBool32(dec, &val->multiDrawIndirect);
+    vn_decode_VkBool32(dec, &val->drawIndirectFirstInstance);
+    vn_decode_VkBool32(dec, &val->depthClamp);
+    vn_decode_VkBool32(dec, &val->depthBiasClamp);
+    vn_decode_VkBool32(dec, &val->fillModeNonSolid);
+    vn_decode_VkBool32(dec, &val->depthBounds);
+    vn_decode_VkBool32(dec, &val->wideLines);
+    vn_decode_VkBool32(dec, &val->largePoints);
+    vn_decode_VkBool32(dec, &val->alphaToOne);
+    vn_decode_VkBool32(dec, &val->multiViewport);
+    vn_decode_VkBool32(dec, &val->samplerAnisotropy);
+    vn_decode_VkBool32(dec, &val->textureCompressionETC2);
+    vn_decode_VkBool32(dec, &val->textureCompressionASTC_LDR);
+    vn_decode_VkBool32(dec, &val->textureCompressionBC);
+    vn_decode_VkBool32(dec, &val->occlusionQueryPrecise);
+    vn_decode_VkBool32(dec, &val->pipelineStatisticsQuery);
+    vn_decode_VkBool32(dec, &val->vertexPipelineStoresAndAtomics);
+    vn_decode_VkBool32(dec, &val->fragmentStoresAndAtomics);
+    vn_decode_VkBool32(dec, &val->shaderTessellationAndGeometryPointSize);
+    vn_decode_VkBool32(dec, &val->shaderImageGatherExtended);
+    vn_decode_VkBool32(dec, &val->shaderStorageImageExtendedFormats);
+    vn_decode_VkBool32(dec, &val->shaderStorageImageMultisample);
+    vn_decode_VkBool32(dec, &val->shaderStorageImageReadWithoutFormat);
+    vn_decode_VkBool32(dec, &val->shaderStorageImageWriteWithoutFormat);
+    vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayDynamicIndexing);
+    vn_decode_VkBool32(dec, &val->shaderSampledImageArrayDynamicIndexing);
+    vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayDynamicIndexing);
+    vn_decode_VkBool32(dec, &val->shaderStorageImageArrayDynamicIndexing);
+    vn_decode_VkBool32(dec, &val->shaderClipDistance);
+    vn_decode_VkBool32(dec, &val->shaderCullDistance);
+    vn_decode_VkBool32(dec, &val->shaderFloat64);
+    vn_decode_VkBool32(dec, &val->shaderInt64);
+    vn_decode_VkBool32(dec, &val->shaderInt16);
+    vn_decode_VkBool32(dec, &val->shaderResourceResidency);
+    vn_decode_VkBool32(dec, &val->shaderResourceMinLod);
+    vn_decode_VkBool32(dec, &val->sparseBinding);
+    vn_decode_VkBool32(dec, &val->sparseResidencyBuffer);
+    vn_decode_VkBool32(dec, &val->sparseResidencyImage2D);
+    vn_decode_VkBool32(dec, &val->sparseResidencyImage3D);
+    vn_decode_VkBool32(dec, &val->sparseResidency2Samples);
+    vn_decode_VkBool32(dec, &val->sparseResidency4Samples);
+    vn_decode_VkBool32(dec, &val->sparseResidency8Samples);
+    vn_decode_VkBool32(dec, &val->sparseResidency16Samples);
+    vn_decode_VkBool32(dec, &val->sparseResidencyAliased);
+    vn_decode_VkBool32(dec, &val->variableMultisampleRate);
+    vn_decode_VkBool32(dec, &val->inheritedQueries);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFeatures_partial(const VkPhysicalDeviceFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->robustBufferAccess */
+    /* skip val->fullDrawIndexUint32 */
+    /* skip val->imageCubeArray */
+    /* skip val->independentBlend */
+    /* skip val->geometryShader */
+    /* skip val->tessellationShader */
+    /* skip val->sampleRateShading */
+    /* skip val->dualSrcBlend */
+    /* skip val->logicOp */
+    /* skip val->multiDrawIndirect */
+    /* skip val->drawIndirectFirstInstance */
+    /* skip val->depthClamp */
+    /* skip val->depthBiasClamp */
+    /* skip val->fillModeNonSolid */
+    /* skip val->depthBounds */
+    /* skip val->wideLines */
+    /* skip val->largePoints */
+    /* skip val->alphaToOne */
+    /* skip val->multiViewport */
+    /* skip val->samplerAnisotropy */
+    /* skip val->textureCompressionETC2 */
+    /* skip val->textureCompressionASTC_LDR */
+    /* skip val->textureCompressionBC */
+    /* skip val->occlusionQueryPrecise */
+    /* skip val->pipelineStatisticsQuery */
+    /* skip val->vertexPipelineStoresAndAtomics */
+    /* skip val->fragmentStoresAndAtomics */
+    /* skip val->shaderTessellationAndGeometryPointSize */
+    /* skip val->shaderImageGatherExtended */
+    /* skip val->shaderStorageImageExtendedFormats */
+    /* skip val->shaderStorageImageMultisample */
+    /* skip val->shaderStorageImageReadWithoutFormat */
+    /* skip val->shaderStorageImageWriteWithoutFormat */
+    /* skip val->shaderUniformBufferArrayDynamicIndexing */
+    /* skip val->shaderSampledImageArrayDynamicIndexing */
+    /* skip val->shaderStorageBufferArrayDynamicIndexing */
+    /* skip val->shaderStorageImageArrayDynamicIndexing */
+    /* skip val->shaderClipDistance */
+    /* skip val->shaderCullDistance */
+    /* skip val->shaderFloat64 */
+    /* skip val->shaderInt64 */
+    /* skip val->shaderInt16 */
+    /* skip val->shaderResourceResidency */
+    /* skip val->shaderResourceMinLod */
+    /* skip val->sparseBinding */
+    /* skip val->sparseResidencyBuffer */
+    /* skip val->sparseResidencyImage2D */
+    /* skip val->sparseResidencyImage3D */
+    /* skip val->sparseResidency2Samples */
+    /* skip val->sparseResidency4Samples */
+    /* skip val->sparseResidency8Samples */
+    /* skip val->sparseResidency16Samples */
+    /* skip val->sparseResidencyAliased */
+    /* skip val->variableMultisampleRate */
+    /* skip val->inheritedQueries */
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val)
+{
+    /* skip val->robustBufferAccess */
+    /* skip val->fullDrawIndexUint32 */
+    /* skip val->imageCubeArray */
+    /* skip val->independentBlend */
+    /* skip val->geometryShader */
+    /* skip val->tessellationShader */
+    /* skip val->sampleRateShading */
+    /* skip val->dualSrcBlend */
+    /* skip val->logicOp */
+    /* skip val->multiDrawIndirect */
+    /* skip val->drawIndirectFirstInstance */
+    /* skip val->depthClamp */
+    /* skip val->depthBiasClamp */
+    /* skip val->fillModeNonSolid */
+    /* skip val->depthBounds */
+    /* skip val->wideLines */
+    /* skip val->largePoints */
+    /* skip val->alphaToOne */
+    /* skip val->multiViewport */
+    /* skip val->samplerAnisotropy */
+    /* skip val->textureCompressionETC2 */
+    /* skip val->textureCompressionASTC_LDR */
+    /* skip val->textureCompressionBC */
+    /* skip val->occlusionQueryPrecise */
+    /* skip val->pipelineStatisticsQuery */
+    /* skip val->vertexPipelineStoresAndAtomics */
+    /* skip val->fragmentStoresAndAtomics */
+    /* skip val->shaderTessellationAndGeometryPointSize */
+    /* skip val->shaderImageGatherExtended */
+    /* skip val->shaderStorageImageExtendedFormats */
+    /* skip val->shaderStorageImageMultisample */
+    /* skip val->shaderStorageImageReadWithoutFormat */
+    /* skip val->shaderStorageImageWriteWithoutFormat */
+    /* skip val->shaderUniformBufferArrayDynamicIndexing */
+    /* skip val->shaderSampledImageArrayDynamicIndexing */
+    /* skip val->shaderStorageBufferArrayDynamicIndexing */
+    /* skip val->shaderStorageImageArrayDynamicIndexing */
+    /* skip val->shaderClipDistance */
+    /* skip val->shaderCullDistance */
+    /* skip val->shaderFloat64 */
+    /* skip val->shaderInt64 */
+    /* skip val->shaderInt16 */
+    /* skip val->shaderResourceResidency */
+    /* skip val->shaderResourceMinLod */
+    /* skip val->sparseBinding */
+    /* skip val->sparseResidencyBuffer */
+    /* skip val->sparseResidencyImage2D */
+    /* skip val->sparseResidencyImage3D */
+    /* skip val->sparseResidency2Samples */
+    /* skip val->sparseResidency4Samples */
+    /* skip val->sparseResidency8Samples */
+    /* skip val->sparseResidency16Samples */
+    /* skip val->sparseResidencyAliased */
+    /* skip val->variableMultisampleRate */
+    /* skip val->inheritedQueries */
+}
+
+/* struct VkFormatProperties */
+
+static inline size_t
+vn_sizeof_VkFormatProperties(const VkFormatProperties *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->linearTilingFeatures);
+    size += vn_sizeof_VkFlags(&val->optimalTilingFeatures);
+    size += vn_sizeof_VkFlags(&val->bufferFeatures);
+    return size;
+}
+
+static inline void
+vn_decode_VkFormatProperties(struct vn_cs_decoder *dec, VkFormatProperties *val)
+{
+    vn_decode_VkFlags(dec, &val->linearTilingFeatures);
+    vn_decode_VkFlags(dec, &val->optimalTilingFeatures);
+    vn_decode_VkFlags(dec, &val->bufferFeatures);
+}
+
+static inline size_t
+vn_sizeof_VkFormatProperties_partial(const VkFormatProperties *val)
+{
+    size_t size = 0;
+    /* skip val->linearTilingFeatures */
+    /* skip val->optimalTilingFeatures */
+    /* skip val->bufferFeatures */
+    return size;
+}
+
+static inline void
+vn_encode_VkFormatProperties_partial(struct vn_cs_encoder *enc, const VkFormatProperties *val)
+{
+    /* skip val->linearTilingFeatures */
+    /* skip val->optimalTilingFeatures */
+    /* skip val->bufferFeatures */
+}
+
+/* struct VkImageFormatProperties */
+
+static inline size_t
+vn_sizeof_VkImageFormatProperties(const VkImageFormatProperties *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkExtent3D(&val->maxExtent);
+    size += vn_sizeof_uint32_t(&val->maxMipLevels);
+    size += vn_sizeof_uint32_t(&val->maxArrayLayers);
+    size += vn_sizeof_VkFlags(&val->sampleCounts);
+    size += vn_sizeof_VkDeviceSize(&val->maxResourceSize);
+    return size;
+}
+
+static inline void
+vn_decode_VkImageFormatProperties(struct vn_cs_decoder *dec, VkImageFormatProperties *val)
+{
+    vn_decode_VkExtent3D(dec, &val->maxExtent);
+    vn_decode_uint32_t(dec, &val->maxMipLevels);
+    vn_decode_uint32_t(dec, &val->maxArrayLayers);
+    vn_decode_VkFlags(dec, &val->sampleCounts);
+    vn_decode_VkDeviceSize(dec, &val->maxResourceSize);
+}
+
+static inline size_t
+vn_sizeof_VkImageFormatProperties_partial(const VkImageFormatProperties *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkExtent3D_partial(&val->maxExtent);
+    /* skip val->maxMipLevels */
+    /* skip val->maxArrayLayers */
+    /* skip val->sampleCounts */
+    /* skip val->maxResourceSize */
+    return size;
+}
+
+static inline void
+vn_encode_VkImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties *val)
+{
+    vn_encode_VkExtent3D_partial(enc, &val->maxExtent);
+    /* skip val->maxMipLevels */
+    /* skip val->maxArrayLayers */
+    /* skip val->sampleCounts */
+    /* skip val->maxResourceSize */
+}
+
+/* struct VkDeviceQueueCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDeviceQueueCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDeviceQueueCreateInfo_self(const VkDeviceQueueCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
+    size += vn_sizeof_uint32_t(&val->queueCount);
+    if (val->pQueuePriorities) {
+        size += vn_sizeof_array_size(val->queueCount);
+        size += vn_sizeof_float_array(val->pQueuePriorities, val->queueCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDeviceQueueCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDeviceQueueCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDeviceQueueCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDeviceQueueCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceQueueCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->queueFamilyIndex);
+    vn_encode_uint32_t(enc, &val->queueCount);
+    if (val->pQueuePriorities) {
+        vn_encode_array_size(enc, val->queueCount);
+        vn_encode_float_array(enc, val->pQueuePriorities, val->queueCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDeviceQueueCreateInfo(struct vn_cs_encoder *enc, const VkDeviceQueueCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO });
+    vn_encode_VkDeviceQueueCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDeviceQueueCreateInfo_self(enc, val);
+}
+
+/* struct VkPhysicalDeviceVariablePointersFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(const VkPhysicalDeviceVariablePointersFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
+    size += vn_sizeof_VkBool32(&val->variablePointers);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
+    vn_encode_VkBool32(enc, &val->variablePointers);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
+    vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
+    vn_decode_VkBool32(dec, &val->variablePointers);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(const VkPhysicalDeviceVariablePointersFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->variablePointersStorageBuffer */
+    /* skip val->variablePointers */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_partial(const VkPhysicalDeviceVariablePointersFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->variablePointersStorageBuffer */
+    /* skip val->variablePointers */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVariablePointersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
+    vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceMultiviewFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(const VkPhysicalDeviceMultiviewFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->multiview);
+    size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
+    size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->multiview);
+    vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
+    vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
+    vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->multiview);
+    vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
+    vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(const VkPhysicalDeviceMultiviewFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->multiview */
+    /* skip val->multiviewGeometryShader */
+    /* skip val->multiviewTessellationShader */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewFeatures_partial(const VkPhysicalDeviceMultiviewFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->multiview */
+    /* skip val->multiviewGeometryShader */
+    /* skip val->multiviewTessellationShader */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMultiviewFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
+    vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDevice16BitStorageFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(const VkPhysicalDevice16BitStorageFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
+    size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
+    size += vn_sizeof_VkBool32(&val->storagePushConstant16);
+    size += vn_sizeof_VkBool32(&val->storageInputOutput16);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
+    vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
+    vn_encode_VkBool32(enc, &val->storagePushConstant16);
+    vn_encode_VkBool32(enc, &val->storageInputOutput16);
+}
+
+static inline void
+vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
+    vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
+    vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
+    vn_decode_VkBool32(dec, &val->storagePushConstant16);
+    vn_decode_VkBool32(dec, &val->storageInputOutput16);
+}
+
+static inline void
+vn_decode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(const VkPhysicalDevice16BitStorageFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->storageBuffer16BitAccess */
+    /* skip val->uniformAndStorageBuffer16BitAccess */
+    /* skip val->storagePushConstant16 */
+    /* skip val->storageInputOutput16 */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice16BitStorageFeatures_partial(const VkPhysicalDevice16BitStorageFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->storageBuffer16BitAccess */
+    /* skip val->uniformAndStorageBuffer16BitAccess */
+    /* skip val->storagePushConstant16 */
+    /* skip val->storageInputOutput16 */
+}
+
+static inline void
+vn_encode_VkPhysicalDevice16BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
+    vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
+    vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->shaderSubgroupExtendedTypes */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->shaderSubgroupExtendedTypes */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
+    vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceSamplerYcbcrConversionFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
+    vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->samplerYcbcrConversion */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->samplerYcbcrConversion */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
+    vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceProtectedMemoryFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(const VkPhysicalDeviceProtectedMemoryFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->protectedMemory);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->protectedMemory);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
+    vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->protectedMemory);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->protectedMemory */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->protectedMemory */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
+    vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceShaderDrawParametersFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->shaderDrawParameters);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
+    vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->shaderDrawParameters);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->shaderDrawParameters */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->shaderDrawParameters */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
+    vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceShaderFloat16Int8Features chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->shaderFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderInt8);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->shaderFloat16);
+    vn_encode_VkBool32(enc, &val->shaderInt8);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
+    vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->shaderFloat16);
+    vn_decode_VkBool32(dec, &val->shaderInt8);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->shaderFloat16 */
+    /* skip val->shaderInt8 */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->shaderFloat16 */
+    /* skip val->shaderInt8 */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
+    vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceHostQueryResetFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->hostQueryReset);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->hostQueryReset);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
+    vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->hostQueryReset);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->hostQueryReset */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->hostQueryReset */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
+    vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceDescriptorIndexingFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
+    size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
+    vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
+    vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
+    vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
+    vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
+    vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
+    vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
+    vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
+    vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
+    vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
+    vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
+    vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
+    vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
+    vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->shaderInputAttachmentArrayDynamicIndexing */
+    /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
+    /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
+    /* skip val->shaderUniformBufferArrayNonUniformIndexing */
+    /* skip val->shaderSampledImageArrayNonUniformIndexing */
+    /* skip val->shaderStorageBufferArrayNonUniformIndexing */
+    /* skip val->shaderStorageImageArrayNonUniformIndexing */
+    /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
+    /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
+    /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
+    /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
+    /* skip val->descriptorBindingSampledImageUpdateAfterBind */
+    /* skip val->descriptorBindingStorageImageUpdateAfterBind */
+    /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
+    /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
+    /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
+    /* skip val->descriptorBindingUpdateUnusedWhilePending */
+    /* skip val->descriptorBindingPartiallyBound */
+    /* skip val->descriptorBindingVariableDescriptorCount */
+    /* skip val->runtimeDescriptorArray */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->shaderInputAttachmentArrayDynamicIndexing */
+    /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
+    /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
+    /* skip val->shaderUniformBufferArrayNonUniformIndexing */
+    /* skip val->shaderSampledImageArrayNonUniformIndexing */
+    /* skip val->shaderStorageBufferArrayNonUniformIndexing */
+    /* skip val->shaderStorageImageArrayNonUniformIndexing */
+    /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
+    /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
+    /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
+    /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
+    /* skip val->descriptorBindingSampledImageUpdateAfterBind */
+    /* skip val->descriptorBindingStorageImageUpdateAfterBind */
+    /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
+    /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
+    /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
+    /* skip val->descriptorBindingUpdateUnusedWhilePending */
+    /* skip val->descriptorBindingPartiallyBound */
+    /* skip val->descriptorBindingVariableDescriptorCount */
+    /* skip val->runtimeDescriptorArray */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
+    vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceTimelineSemaphoreFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->timelineSemaphore);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->timelineSemaphore);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
+    vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->timelineSemaphore);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->timelineSemaphore */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->timelineSemaphore */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
+    vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDevice8BitStorageFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
+    size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
+    size += vn_sizeof_VkBool32(&val->storagePushConstant8);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
+    vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
+    vn_encode_VkBool32(enc, &val->storagePushConstant8);
+}
+
+static inline void
+vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
+    vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
+    vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
+    vn_decode_VkBool32(dec, &val->storagePushConstant8);
+}
+
+static inline void
+vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->storageBuffer8BitAccess */
+    /* skip val->uniformAndStorageBuffer8BitAccess */
+    /* skip val->storagePushConstant8 */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->storageBuffer8BitAccess */
+    /* skip val->uniformAndStorageBuffer8BitAccess */
+    /* skip val->storagePushConstant8 */
+}
+
+static inline void
+vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
+    vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceVulkanMemoryModelFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
+    size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
+    size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
+    vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
+    vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
+    vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
+    vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
+    vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->vulkanMemoryModel */
+    /* skip val->vulkanMemoryModelDeviceScope */
+    /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->vulkanMemoryModel */
+    /* skip val->vulkanMemoryModelDeviceScope */
+    /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
+    vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceShaderAtomicInt64Features chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
+    size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
+    vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
+    vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
+    vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->shaderBufferInt64Atomics */
+    /* skip val->shaderSharedInt64Atomics */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->shaderBufferInt64Atomics */
+    /* skip val->shaderSharedInt64Atomics */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
+    vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceTransformFeedbackFeaturesEXT chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->transformFeedback);
+    size += vn_sizeof_VkBool32(&val->geometryStreams);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->transformFeedback);
+    vn_encode_VkBool32(enc, &val->geometryStreams);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
+    vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->transformFeedback);
+    vn_decode_VkBool32(dec, &val->geometryStreams);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->transformFeedback */
+    /* skip val->geometryStreams */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->transformFeedback */
+    /* skip val->geometryStreams */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
+    vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceScalarBlockLayoutFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->scalarBlockLayout);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
+    vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->scalarBlockLayout);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->scalarBlockLayout */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->scalarBlockLayout */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
+    vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
+    vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->uniformBufferStandardLayout */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->uniformBufferStandardLayout */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
+    vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceBufferDeviceAddressFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
+    size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
+    size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
+    vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
+    vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
+    vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
+    vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
+    vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->bufferDeviceAddress */
+    /* skip val->bufferDeviceAddressCaptureReplay */
+    /* skip val->bufferDeviceAddressMultiDevice */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->bufferDeviceAddress */
+    /* skip val->bufferDeviceAddressCaptureReplay */
+    /* skip val->bufferDeviceAddressMultiDevice */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
+    vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceImagelessFramebufferFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
+    vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->imagelessFramebuffer */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->imagelessFramebuffer */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
+    vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
+    vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->separateDepthStencilLayouts */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->separateDepthStencilLayouts */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
+    vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceVulkan11Features chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
+    size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
+    size += vn_sizeof_VkBool32(&val->storagePushConstant16);
+    size += vn_sizeof_VkBool32(&val->storageInputOutput16);
+    size += vn_sizeof_VkBool32(&val->multiview);
+    size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
+    size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
+    size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
+    size += vn_sizeof_VkBool32(&val->variablePointers);
+    size += vn_sizeof_VkBool32(&val->protectedMemory);
+    size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
+    size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
+    vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
+    vn_encode_VkBool32(enc, &val->storagePushConstant16);
+    vn_encode_VkBool32(enc, &val->storageInputOutput16);
+    vn_encode_VkBool32(enc, &val->multiview);
+    vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
+    vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
+    vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
+    vn_encode_VkBool32(enc, &val->variablePointers);
+    vn_encode_VkBool32(enc, &val->protectedMemory);
+    vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
+    vn_encode_VkBool32(enc, &val->shaderDrawParameters);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
+    vn_encode_VkPhysicalDeviceVulkan11Features_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
+    vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
+    vn_decode_VkBool32(dec, &val->storagePushConstant16);
+    vn_decode_VkBool32(dec, &val->storageInputOutput16);
+    vn_decode_VkBool32(dec, &val->multiview);
+    vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
+    vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
+    vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
+    vn_decode_VkBool32(dec, &val->variablePointers);
+    vn_decode_VkBool32(dec, &val->protectedMemory);
+    vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
+    vn_decode_VkBool32(dec, &val->shaderDrawParameters);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceVulkan11Features_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->storageBuffer16BitAccess */
+    /* skip val->uniformAndStorageBuffer16BitAccess */
+    /* skip val->storagePushConstant16 */
+    /* skip val->storageInputOutput16 */
+    /* skip val->multiview */
+    /* skip val->multiviewGeometryShader */
+    /* skip val->multiviewTessellationShader */
+    /* skip val->variablePointersStorageBuffer */
+    /* skip val->variablePointers */
+    /* skip val->protectedMemory */
+    /* skip val->samplerYcbcrConversion */
+    /* skip val->shaderDrawParameters */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->storageBuffer16BitAccess */
+    /* skip val->uniformAndStorageBuffer16BitAccess */
+    /* skip val->storagePushConstant16 */
+    /* skip val->storageInputOutput16 */
+    /* skip val->multiview */
+    /* skip val->multiviewGeometryShader */
+    /* skip val->multiviewTessellationShader */
+    /* skip val->variablePointersStorageBuffer */
+    /* skip val->variablePointers */
+    /* skip val->protectedMemory */
+    /* skip val->samplerYcbcrConversion */
+    /* skip val->shaderDrawParameters */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
+    vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceVulkan12Features chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->samplerMirrorClampToEdge);
+    size += vn_sizeof_VkBool32(&val->drawIndirectCount);
+    size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
+    size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
+    size += vn_sizeof_VkBool32(&val->storagePushConstant8);
+    size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
+    size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
+    size += vn_sizeof_VkBool32(&val->shaderFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderInt8);
+    size += vn_sizeof_VkBool32(&val->descriptorIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
+    size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
+    size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
+    size += vn_sizeof_VkBool32(&val->samplerFilterMinmax);
+    size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
+    size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
+    size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
+    size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
+    size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
+    size += vn_sizeof_VkBool32(&val->hostQueryReset);
+    size += vn_sizeof_VkBool32(&val->timelineSemaphore);
+    size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
+    size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
+    size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
+    size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
+    size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
+    size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
+    size += vn_sizeof_VkBool32(&val->shaderOutputViewportIndex);
+    size += vn_sizeof_VkBool32(&val->shaderOutputLayer);
+    size += vn_sizeof_VkBool32(&val->subgroupBroadcastDynamicId);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->samplerMirrorClampToEdge);
+    vn_encode_VkBool32(enc, &val->drawIndirectCount);
+    vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
+    vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
+    vn_encode_VkBool32(enc, &val->storagePushConstant8);
+    vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
+    vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
+    vn_encode_VkBool32(enc, &val->shaderFloat16);
+    vn_encode_VkBool32(enc, &val->shaderInt8);
+    vn_encode_VkBool32(enc, &val->descriptorIndexing);
+    vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
+    vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
+    vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
+    vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
+    vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
+    vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
+    vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
+    vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
+    vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
+    vn_encode_VkBool32(enc, &val->samplerFilterMinmax);
+    vn_encode_VkBool32(enc, &val->scalarBlockLayout);
+    vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
+    vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
+    vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
+    vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
+    vn_encode_VkBool32(enc, &val->hostQueryReset);
+    vn_encode_VkBool32(enc, &val->timelineSemaphore);
+    vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
+    vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
+    vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
+    vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
+    vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
+    vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
+    vn_encode_VkBool32(enc, &val->shaderOutputViewportIndex);
+    vn_encode_VkBool32(enc, &val->shaderOutputLayer);
+    vn_encode_VkBool32(enc, &val->subgroupBroadcastDynamicId);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
+    vn_encode_VkPhysicalDeviceVulkan12Features_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->samplerMirrorClampToEdge);
+    vn_decode_VkBool32(dec, &val->drawIndirectCount);
+    vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
+    vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
+    vn_decode_VkBool32(dec, &val->storagePushConstant8);
+    vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
+    vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
+    vn_decode_VkBool32(dec, &val->shaderFloat16);
+    vn_decode_VkBool32(dec, &val->shaderInt8);
+    vn_decode_VkBool32(dec, &val->descriptorIndexing);
+    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
+    vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
+    vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
+    vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
+    vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
+    vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
+    vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
+    vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
+    vn_decode_VkBool32(dec, &val->samplerFilterMinmax);
+    vn_decode_VkBool32(dec, &val->scalarBlockLayout);
+    vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
+    vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
+    vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
+    vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
+    vn_decode_VkBool32(dec, &val->hostQueryReset);
+    vn_decode_VkBool32(dec, &val->timelineSemaphore);
+    vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
+    vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
+    vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
+    vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
+    vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
+    vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
+    vn_decode_VkBool32(dec, &val->shaderOutputViewportIndex);
+    vn_decode_VkBool32(dec, &val->shaderOutputLayer);
+    vn_decode_VkBool32(dec, &val->subgroupBroadcastDynamicId);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceVulkan12Features_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->samplerMirrorClampToEdge */
+    /* skip val->drawIndirectCount */
+    /* skip val->storageBuffer8BitAccess */
+    /* skip val->uniformAndStorageBuffer8BitAccess */
+    /* skip val->storagePushConstant8 */
+    /* skip val->shaderBufferInt64Atomics */
+    /* skip val->shaderSharedInt64Atomics */
+    /* skip val->shaderFloat16 */
+    /* skip val->shaderInt8 */
+    /* skip val->descriptorIndexing */
+    /* skip val->shaderInputAttachmentArrayDynamicIndexing */
+    /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
+    /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
+    /* skip val->shaderUniformBufferArrayNonUniformIndexing */
+    /* skip val->shaderSampledImageArrayNonUniformIndexing */
+    /* skip val->shaderStorageBufferArrayNonUniformIndexing */
+    /* skip val->shaderStorageImageArrayNonUniformIndexing */
+    /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
+    /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
+    /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
+    /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
+    /* skip val->descriptorBindingSampledImageUpdateAfterBind */
+    /* skip val->descriptorBindingStorageImageUpdateAfterBind */
+    /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
+    /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
+    /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
+    /* skip val->descriptorBindingUpdateUnusedWhilePending */
+    /* skip val->descriptorBindingPartiallyBound */
+    /* skip val->descriptorBindingVariableDescriptorCount */
+    /* skip val->runtimeDescriptorArray */
+    /* skip val->samplerFilterMinmax */
+    /* skip val->scalarBlockLayout */
+    /* skip val->imagelessFramebuffer */
+    /* skip val->uniformBufferStandardLayout */
+    /* skip val->shaderSubgroupExtendedTypes */
+    /* skip val->separateDepthStencilLayouts */
+    /* skip val->hostQueryReset */
+    /* skip val->timelineSemaphore */
+    /* skip val->bufferDeviceAddress */
+    /* skip val->bufferDeviceAddressCaptureReplay */
+    /* skip val->bufferDeviceAddressMultiDevice */
+    /* skip val->vulkanMemoryModel */
+    /* skip val->vulkanMemoryModelDeviceScope */
+    /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
+    /* skip val->shaderOutputViewportIndex */
+    /* skip val->shaderOutputLayer */
+    /* skip val->subgroupBroadcastDynamicId */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->samplerMirrorClampToEdge */
+    /* skip val->drawIndirectCount */
+    /* skip val->storageBuffer8BitAccess */
+    /* skip val->uniformAndStorageBuffer8BitAccess */
+    /* skip val->storagePushConstant8 */
+    /* skip val->shaderBufferInt64Atomics */
+    /* skip val->shaderSharedInt64Atomics */
+    /* skip val->shaderFloat16 */
+    /* skip val->shaderInt8 */
+    /* skip val->descriptorIndexing */
+    /* skip val->shaderInputAttachmentArrayDynamicIndexing */
+    /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
+    /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
+    /* skip val->shaderUniformBufferArrayNonUniformIndexing */
+    /* skip val->shaderSampledImageArrayNonUniformIndexing */
+    /* skip val->shaderStorageBufferArrayNonUniformIndexing */
+    /* skip val->shaderStorageImageArrayNonUniformIndexing */
+    /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
+    /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
+    /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
+    /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
+    /* skip val->descriptorBindingSampledImageUpdateAfterBind */
+    /* skip val->descriptorBindingStorageImageUpdateAfterBind */
+    /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
+    /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
+    /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
+    /* skip val->descriptorBindingUpdateUnusedWhilePending */
+    /* skip val->descriptorBindingPartiallyBound */
+    /* skip val->descriptorBindingVariableDescriptorCount */
+    /* skip val->runtimeDescriptorArray */
+    /* skip val->samplerFilterMinmax */
+    /* skip val->scalarBlockLayout */
+    /* skip val->imagelessFramebuffer */
+    /* skip val->uniformBufferStandardLayout */
+    /* skip val->shaderSubgroupExtendedTypes */
+    /* skip val->separateDepthStencilLayouts */
+    /* skip val->hostQueryReset */
+    /* skip val->timelineSemaphore */
+    /* skip val->bufferDeviceAddress */
+    /* skip val->bufferDeviceAddressCaptureReplay */
+    /* skip val->bufferDeviceAddressMultiDevice */
+    /* skip val->vulkanMemoryModel */
+    /* skip val->vulkanMemoryModelDeviceScope */
+    /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
+    /* skip val->shaderOutputViewportIndex */
+    /* skip val->shaderOutputLayer */
+    /* skip val->subgroupBroadcastDynamicId */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
+    vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceFeatures2 chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkPhysicalDeviceFeatures(&val->features);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceFeatures2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkPhysicalDeviceFeatures(enc, &val->features);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
+    vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceFeatures2_self(enc, val);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return;
+
+    vn_decode_VkStructureType(dec, &stype);
+    while (true) {
+        assert(pnext);
+        if (pnext->sType == stype)
+            break;
+    }
+
+    switch ((int32_t)pnext->sType) {
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, (VkPhysicalDeviceMultiviewFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, (VkPhysicalDevice16BitStorageFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, (VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, (VkPhysicalDeviceHostQueryResetFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, (VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, (VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, (VkPhysicalDevice8BitStorageFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, (VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, (VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, (VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, (VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, (VkPhysicalDeviceVulkan11Features *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, (VkPhysicalDeviceVulkan12Features *)pnext);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkPhysicalDeviceFeatures(dec, &val->features);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceFeatures2_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial((const VkPhysicalDeviceMultiviewFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial((const VkPhysicalDevice16BitStorageFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial((const VkPhysicalDevice8BitStorageFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial((const VkPhysicalDeviceVulkan11Features *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial((const VkPhysicalDeviceVulkan12Features *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkPhysicalDeviceFeatures_partial(&val->features);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkPhysicalDeviceFeatures_partial(enc, &val->features);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
+    vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceFeatures2_self_partial(enc, val);
+}
+
+/* struct VkDeviceGroupDeviceCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
+    if (val->pPhysicalDevices) {
+        size += vn_sizeof_array_size(val->physicalDeviceCount);
+        for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
+            size += vn_sizeof_VkPhysicalDevice(&val->pPhysicalDevices[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->physicalDeviceCount);
+    if (val->pPhysicalDevices) {
+        vn_encode_array_size(enc, val->physicalDeviceCount);
+        for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
+            vn_encode_VkPhysicalDevice(enc, &val->pPhysicalDevices[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO });
+    vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, val);
+}
+
+/* struct VkDeviceCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDeviceCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceFeatures2_self((const VkPhysicalDeviceFeatures2 *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self((const VkDeviceGroupDeviceCreateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->queueCreateInfoCount);
+    if (val->pQueueCreateInfos) {
+        size += vn_sizeof_array_size(val->queueCreateInfoCount);
+        for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
+            size += vn_sizeof_VkDeviceQueueCreateInfo(&val->pQueueCreateInfos[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->enabledLayerCount);
+    if (val->ppEnabledLayerNames) {
+        size += vn_sizeof_array_size(val->enabledLayerCount);
+        for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
+            size += vn_sizeof_array_size(string_size);
+            size += vn_sizeof_blob_array(val->ppEnabledLayerNames[i], string_size);
+        }
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->enabledExtensionCount);
+    if (val->ppEnabledExtensionNames) {
+        size += vn_sizeof_array_size(val->enabledExtensionCount);
+        for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
+            size += vn_sizeof_array_size(string_size);
+            size += vn_sizeof_blob_array(val->ppEnabledExtensionNames[i], string_size);
+        }
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_simple_pointer(val->pEnabledFeatures);
+    if (val->pEnabledFeatures)
+        size += vn_sizeof_VkPhysicalDeviceFeatures(val->pEnabledFeatures);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDeviceCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDeviceCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceFeatures2_self(enc, (const VkPhysicalDeviceFeatures2 *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, (const VkDeviceGroupDeviceCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->queueCreateInfoCount);
+    if (val->pQueueCreateInfos) {
+        vn_encode_array_size(enc, val->queueCreateInfoCount);
+        for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
+            vn_encode_VkDeviceQueueCreateInfo(enc, &val->pQueueCreateInfos[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->enabledLayerCount);
+    if (val->ppEnabledLayerNames) {
+        vn_encode_array_size(enc, val->enabledLayerCount);
+        for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
+            vn_encode_array_size(enc, string_size);
+            vn_encode_blob_array(enc, val->ppEnabledLayerNames[i], string_size);
+        }
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->enabledExtensionCount);
+    if (val->ppEnabledExtensionNames) {
+        vn_encode_array_size(enc, val->enabledExtensionCount);
+        for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
+            vn_encode_array_size(enc, string_size);
+            vn_encode_blob_array(enc, val->ppEnabledExtensionNames[i], string_size);
+        }
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (vn_encode_simple_pointer(enc, val->pEnabledFeatures))
+        vn_encode_VkPhysicalDeviceFeatures(enc, val->pEnabledFeatures);
+}
+
+static inline void
+vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO });
+    vn_encode_VkDeviceCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDeviceCreateInfo_self(enc, val);
+}
+
+/* struct VkConformanceVersion */
+
+static inline size_t
+vn_sizeof_VkConformanceVersion(const VkConformanceVersion *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint8_t(&val->major);
+    size += vn_sizeof_uint8_t(&val->minor);
+    size += vn_sizeof_uint8_t(&val->subminor);
+    size += vn_sizeof_uint8_t(&val->patch);
+    return size;
+}
+
+static inline void
+vn_decode_VkConformanceVersion(struct vn_cs_decoder *dec, VkConformanceVersion *val)
+{
+    vn_decode_uint8_t(dec, &val->major);
+    vn_decode_uint8_t(dec, &val->minor);
+    vn_decode_uint8_t(dec, &val->subminor);
+    vn_decode_uint8_t(dec, &val->patch);
+}
+
+static inline size_t
+vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion *val)
+{
+    size_t size = 0;
+    /* skip val->major */
+    /* skip val->minor */
+    /* skip val->subminor */
+    /* skip val->patch */
+    return size;
+}
+
+static inline void
+vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder *enc, const VkConformanceVersion *val)
+{
+    /* skip val->major */
+    /* skip val->minor */
+    /* skip val->subminor */
+    /* skip val->patch */
+}
+
+/* struct VkPhysicalDeviceDriverProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDriverId(&val->driverID);
+    size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
+    size += vn_sizeof_blob_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
+    size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
+    size += vn_sizeof_blob_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
+    size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceDriverProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkDriverId(dec, &val->driverID);
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
+        vn_decode_blob_array(dec, val->driverName, array_size);
+    }
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
+        vn_decode_blob_array(dec, val->driverInfo, array_size);
+    }
+    vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceDriverProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceDriverProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->driverID */
+    /* skip val->driverName */
+    /* skip val->driverInfo */
+    size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->driverID */
+    /* skip val->driverName */
+    /* skip val->driverInfo */
+    vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES });
+    vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceIDProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_array_size(VK_UUID_SIZE);
+    size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
+    size += vn_sizeof_array_size(VK_UUID_SIZE);
+    size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
+    size += vn_sizeof_array_size(VK_LUID_SIZE);
+    size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
+    size += vn_sizeof_uint32_t(&val->deviceNodeMask);
+    size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceIDProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
+        vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
+    }
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
+        vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
+    }
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
+        vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
+    }
+    vn_decode_uint32_t(dec, &val->deviceNodeMask);
+    vn_decode_VkBool32(dec, &val->deviceLUIDValid);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceIDProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceIDProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->deviceUUID */
+    /* skip val->driverUUID */
+    /* skip val->deviceLUID */
+    /* skip val->deviceNodeMask */
+    /* skip val->deviceLUIDValid */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->deviceUUID */
+    /* skip val->driverUUID */
+    /* skip val->deviceLUID */
+    /* skip val->deviceNodeMask */
+    /* skip val->deviceLUIDValid */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES });
+    vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceMultiviewProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
+    size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
+    vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->maxMultiviewViewCount */
+    /* skip val->maxMultiviewInstanceIndex */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->maxMultiviewViewCount */
+    /* skip val->maxMultiviewInstanceIndex */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES });
+    vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceSubgroupProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->subgroupSize);
+    size += vn_sizeof_VkFlags(&val->supportedStages);
+    size += vn_sizeof_VkFlags(&val->supportedOperations);
+    size += vn_sizeof_VkBool32(&val->quadOperationsInAllStages);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->subgroupSize);
+    vn_decode_VkFlags(dec, &val->supportedStages);
+    vn_decode_VkFlags(dec, &val->supportedOperations);
+    vn_decode_VkBool32(dec, &val->quadOperationsInAllStages);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->subgroupSize */
+    /* skip val->supportedStages */
+    /* skip val->supportedOperations */
+    /* skip val->quadOperationsInAllStages */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->subgroupSize */
+    /* skip val->supportedStages */
+    /* skip val->supportedOperations */
+    /* skip val->quadOperationsInAllStages */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES });
+    vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDevicePointClippingProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
+}
+
+static inline void
+vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDevicePointClippingProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->pointClippingBehavior */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->pointClippingBehavior */
+}
+
+static inline void
+vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES });
+    vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceProtectedMemoryProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->protectedNoFault);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->protectedNoFault);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->protectedNoFault */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->protectedNoFault */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES });
+    vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceSamplerFilterMinmaxProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
+    size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
+    vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->filterMinmaxSingleComponentFormats */
+    /* skip val->filterMinmaxImageComponentMapping */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->filterMinmaxSingleComponentFormats */
+    /* skip val->filterMinmaxImageComponentMapping */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES });
+    vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceMaintenance3Properties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
+    size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
+    vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->maxPerSetDescriptors */
+    /* skip val->maxMemoryAllocationSize */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->maxPerSetDescriptors */
+    /* skip val->maxMemoryAllocationSize */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES });
+    vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceFloatControlsProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
+    size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
+    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
+    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
+    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
+    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
+    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
+    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
+    vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
+    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
+    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
+    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
+    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
+    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
+    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
+    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
+    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
+    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->denormBehaviorIndependence */
+    /* skip val->roundingModeIndependence */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
+    /* skip val->shaderDenormPreserveFloat16 */
+    /* skip val->shaderDenormPreserveFloat32 */
+    /* skip val->shaderDenormPreserveFloat64 */
+    /* skip val->shaderDenormFlushToZeroFloat16 */
+    /* skip val->shaderDenormFlushToZeroFloat32 */
+    /* skip val->shaderDenormFlushToZeroFloat64 */
+    /* skip val->shaderRoundingModeRTEFloat16 */
+    /* skip val->shaderRoundingModeRTEFloat32 */
+    /* skip val->shaderRoundingModeRTEFloat64 */
+    /* skip val->shaderRoundingModeRTZFloat16 */
+    /* skip val->shaderRoundingModeRTZFloat32 */
+    /* skip val->shaderRoundingModeRTZFloat64 */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->denormBehaviorIndependence */
+    /* skip val->roundingModeIndependence */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
+    /* skip val->shaderDenormPreserveFloat16 */
+    /* skip val->shaderDenormPreserveFloat32 */
+    /* skip val->shaderDenormPreserveFloat64 */
+    /* skip val->shaderDenormFlushToZeroFloat16 */
+    /* skip val->shaderDenormFlushToZeroFloat32 */
+    /* skip val->shaderDenormFlushToZeroFloat64 */
+    /* skip val->shaderRoundingModeRTEFloat16 */
+    /* skip val->shaderRoundingModeRTEFloat32 */
+    /* skip val->shaderRoundingModeRTEFloat64 */
+    /* skip val->shaderRoundingModeRTZFloat16 */
+    /* skip val->shaderRoundingModeRTZFloat32 */
+    /* skip val->shaderRoundingModeRTZFloat64 */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES });
+    vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceDescriptorIndexingProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
+    size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
+    size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
+    size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
+    size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
+    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
+    size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
+    size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
+    vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
+    vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
+    vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
+    vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
+    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
+    vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
+    vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
+    /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
+    /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
+    /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
+    /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
+    /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
+    /* skip val->robustBufferAccessUpdateAfterBind */
+    /* skip val->quadDivergentImplicitLod */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
+    /* skip val->maxPerStageUpdateAfterBindResources */
+    /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
+    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
+    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
+    /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
+    /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
+    /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
+    /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
+    /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
+    /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
+    /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
+    /* skip val->robustBufferAccessUpdateAfterBind */
+    /* skip val->quadDivergentImplicitLod */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
+    /* skip val->maxPerStageUpdateAfterBindResources */
+    /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
+    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
+    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
+    /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
+    /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES });
+    vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceTimelineSemaphoreProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->maxTimelineSemaphoreValueDifference */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->maxTimelineSemaphoreValueDifference */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES });
+    vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceDepthStencilResolveProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
+    size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
+    size += vn_sizeof_VkBool32(&val->independentResolveNone);
+    size += vn_sizeof_VkBool32(&val->independentResolve);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
+    vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
+    vn_decode_VkBool32(dec, &val->independentResolveNone);
+    vn_decode_VkBool32(dec, &val->independentResolve);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->supportedDepthResolveModes */
+    /* skip val->supportedStencilResolveModes */
+    /* skip val->independentResolveNone */
+    /* skip val->independentResolve */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->supportedDepthResolveModes */
+    /* skip val->supportedStencilResolveModes */
+    /* skip val->independentResolveNone */
+    /* skip val->independentResolve */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES });
+    vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceTransformFeedbackPropertiesEXT chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreams);
+    size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBuffers);
+    size += vn_sizeof_VkDeviceSize(&val->maxTransformFeedbackBufferSize);
+    size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreamDataSize);
+    size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataSize);
+    size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataStride);
+    size += vn_sizeof_VkBool32(&val->transformFeedbackQueries);
+    size += vn_sizeof_VkBool32(&val->transformFeedbackStreamsLinesTriangles);
+    size += vn_sizeof_VkBool32(&val->transformFeedbackRasterizationStreamSelect);
+    size += vn_sizeof_VkBool32(&val->transformFeedbackDraw);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreams);
+    vn_decode_uint32_t(dec, &val->maxTransformFeedbackBuffers);
+    vn_decode_VkDeviceSize(dec, &val->maxTransformFeedbackBufferSize);
+    vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreamDataSize);
+    vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataSize);
+    vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataStride);
+    vn_decode_VkBool32(dec, &val->transformFeedbackQueries);
+    vn_decode_VkBool32(dec, &val->transformFeedbackStreamsLinesTriangles);
+    vn_decode_VkBool32(dec, &val->transformFeedbackRasterizationStreamSelect);
+    vn_decode_VkBool32(dec, &val->transformFeedbackDraw);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->maxTransformFeedbackStreams */
+    /* skip val->maxTransformFeedbackBuffers */
+    /* skip val->maxTransformFeedbackBufferSize */
+    /* skip val->maxTransformFeedbackStreamDataSize */
+    /* skip val->maxTransformFeedbackBufferDataSize */
+    /* skip val->maxTransformFeedbackBufferDataStride */
+    /* skip val->transformFeedbackQueries */
+    /* skip val->transformFeedbackStreamsLinesTriangles */
+    /* skip val->transformFeedbackRasterizationStreamSelect */
+    /* skip val->transformFeedbackDraw */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->maxTransformFeedbackStreams */
+    /* skip val->maxTransformFeedbackBuffers */
+    /* skip val->maxTransformFeedbackBufferSize */
+    /* skip val->maxTransformFeedbackStreamDataSize */
+    /* skip val->maxTransformFeedbackBufferDataSize */
+    /* skip val->maxTransformFeedbackBufferDataStride */
+    /* skip val->transformFeedbackQueries */
+    /* skip val->transformFeedbackStreamsLinesTriangles */
+    /* skip val->transformFeedbackRasterizationStreamSelect */
+    /* skip val->transformFeedbackDraw */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT });
+    vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceVulkan11Properties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_array_size(VK_UUID_SIZE);
+    size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
+    size += vn_sizeof_array_size(VK_UUID_SIZE);
+    size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
+    size += vn_sizeof_array_size(VK_LUID_SIZE);
+    size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
+    size += vn_sizeof_uint32_t(&val->deviceNodeMask);
+    size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
+    size += vn_sizeof_uint32_t(&val->subgroupSize);
+    size += vn_sizeof_VkFlags(&val->subgroupSupportedStages);
+    size += vn_sizeof_VkFlags(&val->subgroupSupportedOperations);
+    size += vn_sizeof_VkBool32(&val->subgroupQuadOperationsInAllStages);
+    size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
+    size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
+    size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
+    size += vn_sizeof_VkBool32(&val->protectedNoFault);
+    size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
+    size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
+{
+    /* skip val->{sType,pNext} */
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
+        vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
+    }
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
+        vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
+    }
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
+        vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
+    }
+    vn_decode_uint32_t(dec, &val->deviceNodeMask);
+    vn_decode_VkBool32(dec, &val->deviceLUIDValid);
+    vn_decode_uint32_t(dec, &val->subgroupSize);
+    vn_decode_VkFlags(dec, &val->subgroupSupportedStages);
+    vn_decode_VkFlags(dec, &val->subgroupSupportedOperations);
+    vn_decode_VkBool32(dec, &val->subgroupQuadOperationsInAllStages);
+    vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
+    vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
+    vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
+    vn_decode_VkBool32(dec, &val->protectedNoFault);
+    vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
+    vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->deviceUUID */
+    /* skip val->driverUUID */
+    /* skip val->deviceLUID */
+    /* skip val->deviceNodeMask */
+    /* skip val->deviceLUIDValid */
+    /* skip val->subgroupSize */
+    /* skip val->subgroupSupportedStages */
+    /* skip val->subgroupSupportedOperations */
+    /* skip val->subgroupQuadOperationsInAllStages */
+    /* skip val->pointClippingBehavior */
+    /* skip val->maxMultiviewViewCount */
+    /* skip val->maxMultiviewInstanceIndex */
+    /* skip val->protectedNoFault */
+    /* skip val->maxPerSetDescriptors */
+    /* skip val->maxMemoryAllocationSize */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->deviceUUID */
+    /* skip val->driverUUID */
+    /* skip val->deviceLUID */
+    /* skip val->deviceNodeMask */
+    /* skip val->deviceLUIDValid */
+    /* skip val->subgroupSize */
+    /* skip val->subgroupSupportedStages */
+    /* skip val->subgroupSupportedOperations */
+    /* skip val->subgroupQuadOperationsInAllStages */
+    /* skip val->pointClippingBehavior */
+    /* skip val->maxMultiviewViewCount */
+    /* skip val->maxMultiviewInstanceIndex */
+    /* skip val->protectedNoFault */
+    /* skip val->maxPerSetDescriptors */
+    /* skip val->maxMemoryAllocationSize */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES });
+    vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceVulkan12Properties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDriverId(&val->driverID);
+    size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
+    size += vn_sizeof_blob_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
+    size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
+    size += vn_sizeof_blob_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
+    size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
+    size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
+    size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
+    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
+    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
+    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
+    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
+    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
+    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
+    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
+    size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
+    size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
+    size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
+    size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
+    size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
+    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
+    size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
+    size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
+    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
+    size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
+    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
+    size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
+    size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
+    size += vn_sizeof_VkBool32(&val->independentResolveNone);
+    size += vn_sizeof_VkBool32(&val->independentResolve);
+    size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
+    size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
+    size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
+    size += vn_sizeof_VkFlags(&val->framebufferIntegerColorSampleCounts);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkDriverId(dec, &val->driverID);
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
+        vn_decode_blob_array(dec, val->driverName, array_size);
+    }
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
+        vn_decode_blob_array(dec, val->driverInfo, array_size);
+    }
+    vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
+    vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
+    vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
+    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
+    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
+    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
+    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
+    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
+    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
+    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
+    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
+    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
+    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
+    vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
+    vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
+    vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
+    vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
+    vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
+    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
+    vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
+    vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
+    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
+    vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
+    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
+    vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
+    vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
+    vn_decode_VkBool32(dec, &val->independentResolveNone);
+    vn_decode_VkBool32(dec, &val->independentResolve);
+    vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
+    vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
+    vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
+    vn_decode_VkFlags(dec, &val->framebufferIntegerColorSampleCounts);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->driverID */
+    /* skip val->driverName */
+    /* skip val->driverInfo */
+    size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
+    /* skip val->denormBehaviorIndependence */
+    /* skip val->roundingModeIndependence */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
+    /* skip val->shaderDenormPreserveFloat16 */
+    /* skip val->shaderDenormPreserveFloat32 */
+    /* skip val->shaderDenormPreserveFloat64 */
+    /* skip val->shaderDenormFlushToZeroFloat16 */
+    /* skip val->shaderDenormFlushToZeroFloat32 */
+    /* skip val->shaderDenormFlushToZeroFloat64 */
+    /* skip val->shaderRoundingModeRTEFloat16 */
+    /* skip val->shaderRoundingModeRTEFloat32 */
+    /* skip val->shaderRoundingModeRTEFloat64 */
+    /* skip val->shaderRoundingModeRTZFloat16 */
+    /* skip val->shaderRoundingModeRTZFloat32 */
+    /* skip val->shaderRoundingModeRTZFloat64 */
+    /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
+    /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
+    /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
+    /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
+    /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
+    /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
+    /* skip val->robustBufferAccessUpdateAfterBind */
+    /* skip val->quadDivergentImplicitLod */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
+    /* skip val->maxPerStageUpdateAfterBindResources */
+    /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
+    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
+    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
+    /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
+    /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
+    /* skip val->supportedDepthResolveModes */
+    /* skip val->supportedStencilResolveModes */
+    /* skip val->independentResolveNone */
+    /* skip val->independentResolve */
+    /* skip val->filterMinmaxSingleComponentFormats */
+    /* skip val->filterMinmaxImageComponentMapping */
+    /* skip val->maxTimelineSemaphoreValueDifference */
+    /* skip val->framebufferIntegerColorSampleCounts */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->driverID */
+    /* skip val->driverName */
+    /* skip val->driverInfo */
+    vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
+    /* skip val->denormBehaviorIndependence */
+    /* skip val->roundingModeIndependence */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
+    /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
+    /* skip val->shaderDenormPreserveFloat16 */
+    /* skip val->shaderDenormPreserveFloat32 */
+    /* skip val->shaderDenormPreserveFloat64 */
+    /* skip val->shaderDenormFlushToZeroFloat16 */
+    /* skip val->shaderDenormFlushToZeroFloat32 */
+    /* skip val->shaderDenormFlushToZeroFloat64 */
+    /* skip val->shaderRoundingModeRTEFloat16 */
+    /* skip val->shaderRoundingModeRTEFloat32 */
+    /* skip val->shaderRoundingModeRTEFloat64 */
+    /* skip val->shaderRoundingModeRTZFloat16 */
+    /* skip val->shaderRoundingModeRTZFloat32 */
+    /* skip val->shaderRoundingModeRTZFloat64 */
+    /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
+    /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
+    /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
+    /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
+    /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
+    /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
+    /* skip val->robustBufferAccessUpdateAfterBind */
+    /* skip val->quadDivergentImplicitLod */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
+    /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
+    /* skip val->maxPerStageUpdateAfterBindResources */
+    /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
+    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
+    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
+    /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
+    /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
+    /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
+    /* skip val->supportedDepthResolveModes */
+    /* skip val->supportedStencilResolveModes */
+    /* skip val->independentResolveNone */
+    /* skip val->independentResolve */
+    /* skip val->filterMinmaxSingleComponentFormats */
+    /* skip val->filterMinmaxImageComponentMapping */
+    /* skip val->maxTimelineSemaphoreValueDifference */
+    /* skip val->framebufferIntegerColorSampleCounts */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES });
+    vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceProperties2 chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceDriverProperties_self((const VkPhysicalDeviceDriverProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceIDProperties_self((const VkPhysicalDeviceIDProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self((const VkPhysicalDeviceMultiviewProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self((const VkPhysicalDeviceSubgroupProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self((const VkPhysicalDevicePointClippingProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self((const VkPhysicalDeviceMaintenance3Properties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self((const VkPhysicalDeviceFloatControlsProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self((const VkPhysicalDeviceVulkan11Properties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self((const VkPhysicalDeviceVulkan12Properties *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkPhysicalDeviceProperties(&val->properties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceProperties2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return;
+
+    vn_decode_VkStructureType(dec, &stype);
+    while (true) {
+        assert(pnext);
+        if (pnext->sType == stype)
+            break;
+    }
+
+    switch ((int32_t)pnext->sType) {
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceDriverProperties_self(dec, (VkPhysicalDeviceDriverProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceIDProperties_self(dec, (VkPhysicalDeviceIDProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, (VkPhysicalDeviceMultiviewProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, (VkPhysicalDeviceSubgroupProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, (VkPhysicalDevicePointClippingProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, (VkPhysicalDeviceProtectedMemoryProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, (VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, (VkPhysicalDeviceMaintenance3Properties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, (VkPhysicalDeviceFloatControlsProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, (VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, (VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, (VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, (VkPhysicalDeviceVulkan11Properties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, (VkPhysicalDeviceVulkan12Properties *)pnext);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkPhysicalDeviceProperties(dec, &val->properties);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceProperties2_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceProperties2_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial((const VkPhysicalDeviceDriverProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial((const VkPhysicalDeviceIDProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial((const VkPhysicalDeviceMultiviewProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial((const VkPhysicalDeviceSubgroupProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial((const VkPhysicalDevicePointClippingProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial((const VkPhysicalDeviceMaintenance3Properties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial((const VkPhysicalDeviceFloatControlsProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial((const VkPhysicalDeviceVulkan11Properties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial((const VkPhysicalDeviceVulkan12Properties *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkPhysicalDeviceProperties_partial(&val->properties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceProperties2_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, (const VkPhysicalDeviceDriverProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, (const VkPhysicalDeviceIDProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, (const VkPhysicalDeviceMultiviewProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, (const VkPhysicalDeviceSubgroupProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, (const VkPhysicalDevicePointClippingProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance3Properties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, (const VkPhysicalDeviceFloatControlsProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, (const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, (const VkPhysicalDeviceVulkan11Properties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, (const VkPhysicalDeviceVulkan12Properties *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkPhysicalDeviceProperties_partial(enc, &val->properties);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 });
+    vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceProperties2_self_partial(enc, val);
+}
+
+/* struct VkDrmFormatModifierPropertiesEXT */
+
+static inline size_t
+vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint64_t(&val->drmFormatModifier);
+    size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
+    size += vn_sizeof_VkFlags(&val->drmFormatModifierTilingFeatures);
+    return size;
+}
+
+static inline void
+vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesEXT *val)
+{
+    vn_decode_uint64_t(dec, &val->drmFormatModifier);
+    vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount);
+    vn_decode_VkFlags(dec, &val->drmFormatModifierTilingFeatures);
+}
+
+static inline size_t
+vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT *val)
+{
+    size_t size = 0;
+    /* skip val->drmFormatModifier */
+    /* skip val->drmFormatModifierPlaneCount */
+    /* skip val->drmFormatModifierTilingFeatures */
+    return size;
+}
+
+static inline void
+vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesEXT *val)
+{
+    /* skip val->drmFormatModifier */
+    /* skip val->drmFormatModifierPlaneCount */
+    /* skip val->drmFormatModifierTilingFeatures */
+}
+
+/* struct VkDrmFormatModifierPropertiesListEXT chain */
+
+static inline size_t
+vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
+    if (val->pDrmFormatModifierProperties) {
+        size += vn_sizeof_array_size(val->drmFormatModifierCount);
+        for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
+            size += vn_sizeof_VkDrmFormatModifierPropertiesEXT(&val->pDrmFormatModifierProperties[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(val->pNext);
+    size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->drmFormatModifierCount);
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, val->drmFormatModifierCount);
+        for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
+            vn_decode_VkDrmFormatModifierPropertiesEXT(dec, &val->pDrmFormatModifierProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        val->pDrmFormatModifierProperties = NULL;
+    }
+}
+
+static inline void
+vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
+
+    assert(val->sType == stype);
+    vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(dec, val->pNext);
+    vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->drmFormatModifierCount */
+    if (val->pDrmFormatModifierProperties) {
+        size += vn_sizeof_array_size(val->drmFormatModifierCount);
+        for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
+            size += vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(&val->pDrmFormatModifierProperties[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(val->pNext);
+    size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->drmFormatModifierCount */
+    if (val->pDrmFormatModifierProperties) {
+        vn_encode_array_size(enc, val->drmFormatModifierCount);
+        for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
+            vn_encode_VkDrmFormatModifierPropertiesEXT_partial(enc, &val->pDrmFormatModifierProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT });
+    vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(enc, val->pNext);
+    vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, val);
+}
+
+/* struct VkFormatProperties2 chain */
+
+static inline size_t
+vn_sizeof_VkFormatProperties2_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self((const VkDrmFormatModifierPropertiesListEXT *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFormatProperties(&val->formatProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkFormatProperties2(const VkFormatProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkFormatProperties2_pnext(val->pNext);
+    size += vn_sizeof_VkFormatProperties2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return;
+
+    vn_decode_VkStructureType(dec, &stype);
+    while (true) {
+        assert(pnext);
+        if (pnext->sType == stype)
+            break;
+    }
+
+    switch ((int32_t)pnext->sType) {
+    case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+        vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, (VkDrmFormatModifierPropertiesListEXT *)pnext);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_decode_VkFormatProperties2_self(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkFormatProperties(dec, &val->formatProperties);
+}
+
+static inline void
+vn_decode_VkFormatProperties2(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
+
+    assert(val->sType == stype);
+    vn_decode_VkFormatProperties2_pnext(dec, val->pNext);
+    vn_decode_VkFormatProperties2_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkFormatProperties2_pnext_partial(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial((const VkDrmFormatModifierPropertiesListEXT *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFormatProperties_partial(&val->formatProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkFormatProperties2_pnext_partial(val->pNext);
+    size += vn_sizeof_VkFormatProperties2_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, (const VkDrmFormatModifierPropertiesListEXT *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFormatProperties_partial(enc, &val->formatProperties);
+}
+
+static inline void
+vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 });
+    vn_encode_VkFormatProperties2_pnext_partial(enc, val->pNext);
+    vn_encode_VkFormatProperties2_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceExternalImageFormatInfo chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO });
+    vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, val);
+}
+
+/* struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint64_t(&val->drmFormatModifier);
+    size += vn_sizeof_VkSharingMode(&val->sharingMode);
+    size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
+    if (val->pQueueFamilyIndices) {
+        size += vn_sizeof_array_size(val->queueFamilyIndexCount);
+        size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint64_t(enc, &val->drmFormatModifier);
+    vn_encode_VkSharingMode(enc, &val->sharingMode);
+    vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
+    if (val->pQueueFamilyIndices) {
+        vn_encode_array_size(enc, val->queueFamilyIndexCount);
+        vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT });
+    vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, val);
+}
+
+/* struct VkPhysicalDeviceImageFormatInfo2 chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self((const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
+            size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
+            size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self((const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
+            size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkImageType(&val->type);
+    size += vn_sizeof_VkImageTiling(&val->tiling);
+    size += vn_sizeof_VkFlags(&val->usage);
+    size += vn_sizeof_VkFlags(&val->flags);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, (const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
+            vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
+            vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, (const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
+            vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkImageType(enc, &val->type);
+    vn_encode_VkImageTiling(enc, &val->tiling);
+    vn_encode_VkFlags(enc, &val->usage);
+    vn_encode_VkFlags(enc, &val->flags);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 });
+    vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceImageFormatInfo2_self(enc, val);
+}
+
+/* struct VkExternalMemoryProperties */
+
+static inline size_t
+vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->externalMemoryFeatures);
+    size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
+    size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
+    return size;
+}
+
+static inline void
+vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder *dec, VkExternalMemoryProperties *val)
+{
+    vn_decode_VkFlags(dec, &val->externalMemoryFeatures);
+    vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
+    vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
+}
+
+static inline size_t
+vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties *val)
+{
+    size_t size = 0;
+    /* skip val->externalMemoryFeatures */
+    /* skip val->exportFromImportedHandleTypes */
+    /* skip val->compatibleHandleTypes */
+    return size;
+}
+
+static inline void
+vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder *enc, const VkExternalMemoryProperties *val)
+{
+    /* skip val->externalMemoryFeatures */
+    /* skip val->exportFromImportedHandleTypes */
+    /* skip val->compatibleHandleTypes */
+}
+
+/* struct VkExternalImageFormatProperties chain */
+
+static inline size_t
+vn_sizeof_VkExternalImageFormatProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExternalImageFormatProperties_pnext(val->pNext);
+    size += vn_sizeof_VkExternalImageFormatProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
+}
+
+static inline void
+vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkExternalImageFormatProperties_pnext(dec, val->pNext);
+    vn_decode_VkExternalImageFormatProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExternalImageFormatProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkExternalImageFormatProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
+}
+
+static inline void
+vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES });
+    vn_encode_VkExternalImageFormatProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkExternalImageFormatProperties_self_partial(enc, val);
+}
+
+/* struct VkSamplerYcbcrConversionImageFormatProperties chain */
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->combinedImageSamplerDescriptorCount);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(val->pNext);
+    size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->combinedImageSamplerDescriptorCount);
+}
+
+static inline void
+vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(dec, val->pNext);
+    vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->combinedImageSamplerDescriptorCount */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->combinedImageSamplerDescriptorCount */
+}
+
+static inline void
+vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES });
+    vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, val);
+}
+
+/* struct VkImageFormatProperties2 chain */
+
+static inline size_t
+vn_sizeof_VkImageFormatProperties2_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkExternalImageFormatProperties_self((const VkExternalImageFormatProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
+            size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkImageFormatProperties(&val->imageFormatProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageFormatProperties2_pnext(val->pNext);
+    size += vn_sizeof_VkImageFormatProperties2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return;
+
+    vn_decode_VkStructureType(dec, &stype);
+    while (true) {
+        assert(pnext);
+        if (pnext->sType == stype)
+            break;
+    }
+
+    switch ((int32_t)pnext->sType) {
+    case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+        vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkExternalImageFormatProperties_self(dec, (VkExternalImageFormatProperties *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+        vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
+        vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, (VkSamplerYcbcrConversionImageFormatProperties *)pnext);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkImageFormatProperties(dec, &val->imageFormatProperties);
+}
+
+static inline void
+vn_decode_VkImageFormatProperties2(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
+
+    assert(val->sType == stype);
+    vn_decode_VkImageFormatProperties2_pnext(dec, val->pNext);
+    vn_decode_VkImageFormatProperties2_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkImageFormatProperties2_pnext_partial(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkExternalImageFormatProperties_self_partial((const VkExternalImageFormatProperties *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkImageFormatProperties_partial(&val->imageFormatProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageFormatProperties2_pnext_partial(val->pNext);
+    size += vn_sizeof_VkImageFormatProperties2_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkExternalImageFormatProperties_self_partial(enc, (const VkExternalImageFormatProperties *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, (const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkImageFormatProperties_partial(enc, &val->imageFormatProperties);
+}
+
+static inline void
+vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 });
+    vn_encode_VkImageFormatProperties2_pnext_partial(enc, val->pNext);
+    vn_encode_VkImageFormatProperties2_self_partial(enc, val);
+}
+
+/* struct VkQueueFamilyProperties2 chain */
+
+static inline size_t
+vn_sizeof_VkQueueFamilyProperties2_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkQueueFamilyProperties(&val->queueFamilyProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkQueueFamilyProperties2_pnext(val->pNext);
+    size += vn_sizeof_VkQueueFamilyProperties2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkQueueFamilyProperties(dec, &val->queueFamilyProperties);
+}
+
+static inline void
+vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
+
+    assert(val->sType == stype);
+    vn_decode_VkQueueFamilyProperties2_pnext(dec, val->pNext);
+    vn_decode_VkQueueFamilyProperties2_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkQueueFamilyProperties_partial(&val->queueFamilyProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkQueueFamilyProperties2_pnext_partial(val->pNext);
+    size += vn_sizeof_VkQueueFamilyProperties2_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkQueueFamilyProperties_partial(enc, &val->queueFamilyProperties);
+}
+
+static inline void
+vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 });
+    vn_encode_VkQueueFamilyProperties2_pnext_partial(enc, val->pNext);
+    vn_encode_VkQueueFamilyProperties2_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceMemoryProperties2 chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkPhysicalDeviceMemoryProperties(&val->memoryProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkPhysicalDeviceMemoryProperties(dec, &val->memoryProperties);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceMemoryProperties2_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(&val->memoryProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, &val->memoryProperties);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 });
+    vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceSparseImageFormatInfo2 chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkImageType(&val->type);
+    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
+    size += vn_sizeof_VkFlags(&val->usage);
+    size += vn_sizeof_VkImageTiling(&val->tiling);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkImageType(enc, &val->type);
+    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
+    vn_encode_VkFlags(enc, &val->usage);
+    vn_encode_VkImageTiling(enc, &val->tiling);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 });
+    vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(enc, val);
+}
+
+/* struct VkSparseImageFormatProperties2 chain */
+
+static inline size_t
+vn_sizeof_VkSparseImageFormatProperties2_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkSparseImageFormatProperties(&val->properties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSparseImageFormatProperties2_pnext(val->pNext);
+    size += vn_sizeof_VkSparseImageFormatProperties2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkSparseImageFormatProperties(dec, &val->properties);
+}
+
+static inline void
+vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
+
+    assert(val->sType == stype);
+    vn_decode_VkSparseImageFormatProperties2_pnext(dec, val->pNext);
+    vn_decode_VkSparseImageFormatProperties2_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->properties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(val->pNext);
+    size += vn_sizeof_VkSparseImageFormatProperties2_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkSparseImageFormatProperties_partial(enc, &val->properties);
+}
+
+static inline void
+vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 });
+    vn_encode_VkSparseImageFormatProperties2_pnext_partial(enc, val->pNext);
+    vn_encode_VkSparseImageFormatProperties2_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceExternalBufferInfo chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkFlags(&val->usage);
+    size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkFlags(enc, &val->usage);
+    vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO });
+    vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceExternalBufferInfo_self(enc, val);
+}
+
+/* struct VkExternalBufferProperties chain */
+
+static inline size_t
+vn_sizeof_VkExternalBufferProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExternalBufferProperties_pnext(val->pNext);
+    size += vn_sizeof_VkExternalBufferProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
+}
+
+static inline void
+vn_decode_VkExternalBufferProperties(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkExternalBufferProperties_pnext(dec, val->pNext);
+    vn_decode_VkExternalBufferProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkExternalBufferProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExternalBufferProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkExternalBufferProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
+}
+
+static inline void
+vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES });
+    vn_encode_VkExternalBufferProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkExternalBufferProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceExternalSemaphoreInfo chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(&val->handleType);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkExternalSemaphoreHandleTypeFlagBits(enc, &val->handleType);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO });
+    vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(enc, val);
+}
+
+/* struct VkExternalSemaphoreProperties chain */
+
+static inline size_t
+vn_sizeof_VkExternalSemaphoreProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
+    size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
+    size += vn_sizeof_VkFlags(&val->externalSemaphoreFeatures);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExternalSemaphoreProperties_pnext(val->pNext);
+    size += vn_sizeof_VkExternalSemaphoreProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
+    vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
+    vn_decode_VkFlags(dec, &val->externalSemaphoreFeatures);
+}
+
+static inline void
+vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkExternalSemaphoreProperties_pnext(dec, val->pNext);
+    vn_decode_VkExternalSemaphoreProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->exportFromImportedHandleTypes */
+    /* skip val->compatibleHandleTypes */
+    /* skip val->externalSemaphoreFeatures */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkExternalSemaphoreProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->exportFromImportedHandleTypes */
+    /* skip val->compatibleHandleTypes */
+    /* skip val->externalSemaphoreFeatures */
+}
+
+static inline void
+vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES });
+    vn_encode_VkExternalSemaphoreProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkExternalSemaphoreProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceExternalFenceInfo chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkExternalFenceHandleTypeFlagBits(&val->handleType);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkExternalFenceHandleTypeFlagBits(enc, &val->handleType);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO });
+    vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceExternalFenceInfo_self(enc, val);
+}
+
+/* struct VkExternalFenceProperties chain */
+
+static inline size_t
+vn_sizeof_VkExternalFenceProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
+    size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
+    size += vn_sizeof_VkFlags(&val->externalFenceFeatures);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExternalFenceProperties_pnext(val->pNext);
+    size += vn_sizeof_VkExternalFenceProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
+    vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
+    vn_decode_VkFlags(dec, &val->externalFenceFeatures);
+}
+
+static inline void
+vn_decode_VkExternalFenceProperties(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkExternalFenceProperties_pnext(dec, val->pNext);
+    vn_decode_VkExternalFenceProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkExternalFenceProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->exportFromImportedHandleTypes */
+    /* skip val->compatibleHandleTypes */
+    /* skip val->externalFenceFeatures */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExternalFenceProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkExternalFenceProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->exportFromImportedHandleTypes */
+    /* skip val->compatibleHandleTypes */
+    /* skip val->externalFenceFeatures */
+}
+
+static inline void
+vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES });
+    vn_encode_VkExternalFenceProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkExternalFenceProperties_self_partial(enc, val);
+}
+
+/* struct VkPhysicalDeviceGroupProperties chain */
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
+    size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
+        size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
+    size += vn_sizeof_VkBool32(&val->subsetAllocation);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceGroupProperties_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->physicalDeviceCount);
+    {
+        vn_decode_array_size(dec, VK_MAX_DEVICE_GROUP_SIZE);
+        for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
+            vn_decode_VkPhysicalDevice(dec, &val->physicalDevices[i]);
+    }
+    vn_decode_VkBool32(dec, &val->subsetAllocation);
+}
+
+static inline void
+vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
+
+    assert(val->sType == stype);
+    vn_decode_VkPhysicalDeviceGroupProperties_pnext(dec, val->pNext);
+    vn_decode_VkPhysicalDeviceGroupProperties_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->physicalDeviceCount */
+    size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
+        size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
+    /* skip val->subsetAllocation */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(val->pNext);
+    size += vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->physicalDeviceCount */
+    vn_encode_array_size(enc, VK_MAX_DEVICE_GROUP_SIZE);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
+        vn_encode_VkPhysicalDevice(enc, &val->physicalDevices[i]);
+    /* skip val->subsetAllocation */
+}
+
+static inline void
+vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES });
+    vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(enc, val->pNext);
+    vn_encode_VkPhysicalDeviceGroupProperties_self_partial(enc, val);
+}
+
+/* struct VkDeviceQueueInfo2 chain */
+
+static inline size_t
+vn_sizeof_VkDeviceQueueInfo2_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
+    size += vn_sizeof_uint32_t(&val->queueIndex);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDeviceQueueInfo2_pnext(val->pNext);
+    size += vn_sizeof_VkDeviceQueueInfo2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->queueFamilyIndex);
+    vn_encode_uint32_t(enc, &val->queueIndex);
+}
+
+static inline void
+vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 });
+    vn_encode_VkDeviceQueueInfo2_pnext(enc, val->pNext);
+    vn_encode_VkDeviceQueueInfo2_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkInstance(&instance);
+    cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
+    if (pPhysicalDeviceCount)
+        cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
+    if (pPhysicalDevices) {
+        cmd_size += vn_sizeof_array_size(*pPhysicalDeviceCount);
+        for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++)
+            cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkInstance(enc, &instance);
+    if (vn_encode_simple_pointer(enc, pPhysicalDeviceCount))
+        vn_encode_uint32_t(enc, pPhysicalDeviceCount);
+    if (pPhysicalDevices) {
+        vn_encode_array_size(enc, *pPhysicalDeviceCount);
+        for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++)
+            vn_encode_VkPhysicalDevice(enc, &pPhysicalDevices[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip instance */
+    cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
+    if (pPhysicalDeviceCount)
+        cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
+    if (pPhysicalDevices) {
+        cmd_size += vn_sizeof_array_size(*pPhysicalDeviceCount);
+        for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++)
+            cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip instance */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pPhysicalDeviceCount);
+    } else {
+        pPhysicalDeviceCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pPhysicalDeviceCount);
+        for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++)
+            vn_decode_VkPhysicalDevice(dec, &pPhysicalDevices[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pPhysicalDevices = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pProperties);
+    if (pProperties)
+        cmd_size += vn_sizeof_VkPhysicalDeviceProperties_partial(pProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pProperties))
+        vn_encode_VkPhysicalDeviceProperties_partial(enc, pProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    cmd_size += vn_sizeof_simple_pointer(pProperties);
+    if (pProperties)
+        cmd_size += vn_sizeof_VkPhysicalDeviceProperties(pProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT);
+
+    /* skip physicalDevice */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkPhysicalDeviceProperties(dec, pProperties);
+    } else {
+        pProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
+    if (pQueueFamilyPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
+    if (pQueueFamilyProperties) {
+        cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount);
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
+            cmd_size += vn_sizeof_VkQueueFamilyProperties_partial(&pQueueFamilyProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
+        vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
+    if (pQueueFamilyProperties) {
+        vn_encode_array_size(enc, *pQueueFamilyPropertyCount);
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
+            vn_encode_VkQueueFamilyProperties_partial(enc, &pQueueFamilyProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
+    if (pQueueFamilyPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
+    if (pQueueFamilyProperties) {
+        cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount);
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
+            cmd_size += vn_sizeof_VkQueueFamilyProperties(&pQueueFamilyProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT);
+
+    /* skip physicalDevice */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
+    } else {
+        pQueueFamilyPropertyCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pQueueFamilyPropertyCount);
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
+            vn_decode_VkQueueFamilyProperties(dec, &pQueueFamilyProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pQueueFamilyProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
+    if (pMemoryProperties)
+        cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(pMemoryProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pMemoryProperties))
+        vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, pMemoryProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
+    if (pMemoryProperties)
+        cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties(pMemoryProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT);
+
+    /* skip physicalDevice */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkPhysicalDeviceMemoryProperties(dec, pMemoryProperties);
+    } else {
+        pMemoryProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pFeatures);
+    if (pFeatures)
+        cmd_size += vn_sizeof_VkPhysicalDeviceFeatures_partial(pFeatures);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pFeatures))
+        vn_encode_VkPhysicalDeviceFeatures_partial(enc, pFeatures);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    cmd_size += vn_sizeof_simple_pointer(pFeatures);
+    if (pFeatures)
+        cmd_size += vn_sizeof_VkPhysicalDeviceFeatures(pFeatures);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT);
+
+    /* skip physicalDevice */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkPhysicalDeviceFeatures(dec, pFeatures);
+    } else {
+        pFeatures = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_VkFormat(&format);
+    cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
+    if (pFormatProperties)
+        cmd_size += vn_sizeof_VkFormatProperties_partial(pFormatProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    vn_encode_VkFormat(enc, &format);
+    if (vn_encode_simple_pointer(enc, pFormatProperties))
+        vn_encode_VkFormatProperties_partial(enc, pFormatProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    /* skip format */
+    cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
+    if (pFormatProperties)
+        cmd_size += vn_sizeof_VkFormatProperties(pFormatProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT);
+
+    /* skip physicalDevice */
+    /* skip format */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkFormatProperties(dec, pFormatProperties);
+    } else {
+        pFormatProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_VkFormat(&format);
+    cmd_size += vn_sizeof_VkImageType(&type);
+    cmd_size += vn_sizeof_VkImageTiling(&tiling);
+    cmd_size += vn_sizeof_VkFlags(&usage);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+    cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
+    if (pImageFormatProperties)
+        cmd_size += vn_sizeof_VkImageFormatProperties_partial(pImageFormatProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    vn_encode_VkFormat(enc, &format);
+    vn_encode_VkImageType(enc, &type);
+    vn_encode_VkImageTiling(enc, &tiling);
+    vn_encode_VkFlags(enc, &usage);
+    vn_encode_VkFlags(enc, &flags);
+    if (vn_encode_simple_pointer(enc, pImageFormatProperties))
+        vn_encode_VkImageFormatProperties_partial(enc, pImageFormatProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip physicalDevice */
+    /* skip format */
+    /* skip type */
+    /* skip tiling */
+    /* skip usage */
+    /* skip flags */
+    cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
+    if (pImageFormatProperties)
+        cmd_size += vn_sizeof_VkImageFormatProperties(pImageFormatProperties);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip physicalDevice */
+    /* skip format */
+    /* skip type */
+    /* skip tiling */
+    /* skip usage */
+    /* skip flags */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkImageFormatProperties(dec, pImageFormatProperties);
+    } else {
+        pImageFormatProperties = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkDeviceCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pDevice);
+    if (pDevice)
+        cmd_size += vn_sizeof_VkDevice(pDevice);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkDeviceCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pDevice))
+        vn_encode_VkDevice(enc, pDevice);
+}
+
+static inline size_t vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip physicalDevice */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pDevice);
+    if (pDevice)
+        cmd_size += vn_sizeof_VkDevice(pDevice);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateDevice_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateDevice_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip physicalDevice */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDevice(dec, pDevice);
+    } else {
+        pDevice = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyDevice_reply(VkDevice device, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder *dec, VkDevice device, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyDevice_EXT);
+
+    /* skip device */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pPropertyCount))
+        vn_encode_uint32_t(enc, pPropertyCount);
+    if (pProperties) {
+        vn_encode_array_size(enc, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_encode_VkLayerProperties_partial(enc, &pProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip physicalDevice */
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip physicalDevice */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pPropertyCount);
+    } else {
+        pPropertyCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_decode_VkLayerProperties(dec, &pProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pProperties = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    if (pLayerName) {
+        const size_t string_size = strlen(pLayerName) + 1;
+        cmd_size += vn_sizeof_array_size(string_size);
+        cmd_size += vn_sizeof_blob_array(pLayerName, string_size);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (pLayerName) {
+        const size_t string_size = strlen(pLayerName) + 1;
+        vn_encode_array_size(enc, string_size);
+        vn_encode_blob_array(enc, pLayerName, string_size);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (vn_encode_simple_pointer(enc, pPropertyCount))
+        vn_encode_uint32_t(enc, pPropertyCount);
+    if (pProperties) {
+        vn_encode_array_size(enc, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip physicalDevice */
+    /* skip pLayerName */
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip physicalDevice */
+    /* skip pLayerName */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pPropertyCount);
+    } else {
+        pPropertyCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_decode_VkExtensionProperties(dec, &pProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pProperties = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&queueFamilyIndex);
+    cmd_size += vn_sizeof_uint32_t(&queueIndex);
+    cmd_size += vn_sizeof_simple_pointer(pQueue);
+    if (pQueue)
+        cmd_size += vn_sizeof_VkQueue(pQueue);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetDeviceQueue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &queueFamilyIndex);
+    vn_encode_uint32_t(enc, &queueIndex);
+    if (vn_encode_simple_pointer(enc, pQueue))
+        vn_encode_VkQueue(enc, pQueue);
+}
+
+static inline size_t vn_sizeof_vkGetDeviceQueue_reply(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip queueFamilyIndex */
+    /* skip queueIndex */
+    cmd_size += vn_sizeof_simple_pointer(pQueue);
+    if (pQueue)
+        cmd_size += vn_sizeof_VkQueue(pQueue);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue_EXT);
+
+    /* skip device */
+    /* skip queueFamilyIndex */
+    /* skip queueIndex */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkQueue(dec, pQueue);
+    } else {
+        pQueue = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkDeviceWaitIdle(VkDevice device)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+}
+
+static inline size_t vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder *dec, VkDevice device)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_VkFormat(&format);
+    cmd_size += vn_sizeof_VkImageType(&type);
+    cmd_size += vn_sizeof_VkSampleCountFlagBits(&samples);
+    cmd_size += vn_sizeof_VkFlags(&usage);
+    cmd_size += vn_sizeof_VkImageTiling(&tiling);
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkSparseImageFormatProperties_partial(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    vn_encode_VkFormat(enc, &format);
+    vn_encode_VkImageType(enc, &type);
+    vn_encode_VkSampleCountFlagBits(enc, &samples);
+    vn_encode_VkFlags(enc, &usage);
+    vn_encode_VkImageTiling(enc, &tiling);
+    if (vn_encode_simple_pointer(enc, pPropertyCount))
+        vn_encode_uint32_t(enc, pPropertyCount);
+    if (pProperties) {
+        vn_encode_array_size(enc, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_encode_VkSparseImageFormatProperties_partial(enc, &pProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    /* skip format */
+    /* skip type */
+    /* skip samples */
+    /* skip usage */
+    /* skip tiling */
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkSparseImageFormatProperties(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT);
+
+    /* skip physicalDevice */
+    /* skip format */
+    /* skip type */
+    /* skip samples */
+    /* skip usage */
+    /* skip tiling */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pPropertyCount);
+    } else {
+        pPropertyCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_decode_VkSparseImageFormatProperties(dec, &pProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pFeatures);
+    if (pFeatures)
+        cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2_partial(pFeatures);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pFeatures))
+        vn_encode_VkPhysicalDeviceFeatures2_partial(enc, pFeatures);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    cmd_size += vn_sizeof_simple_pointer(pFeatures);
+    if (pFeatures)
+        cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2(pFeatures);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT);
+
+    /* skip physicalDevice */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkPhysicalDeviceFeatures2(dec, pFeatures);
+    } else {
+        pFeatures = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pProperties);
+    if (pProperties)
+        cmd_size += vn_sizeof_VkPhysicalDeviceProperties2_partial(pProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pProperties))
+        vn_encode_VkPhysicalDeviceProperties2_partial(enc, pProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    cmd_size += vn_sizeof_simple_pointer(pProperties);
+    if (pProperties)
+        cmd_size += vn_sizeof_VkPhysicalDeviceProperties2(pProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT);
+
+    /* skip physicalDevice */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkPhysicalDeviceProperties2(dec, pProperties);
+    } else {
+        pProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_VkFormat(&format);
+    cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
+    if (pFormatProperties)
+        cmd_size += vn_sizeof_VkFormatProperties2_partial(pFormatProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    vn_encode_VkFormat(enc, &format);
+    if (vn_encode_simple_pointer(enc, pFormatProperties))
+        vn_encode_VkFormatProperties2_partial(enc, pFormatProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    /* skip format */
+    cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
+    if (pFormatProperties)
+        cmd_size += vn_sizeof_VkFormatProperties2(pFormatProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT);
+
+    /* skip physicalDevice */
+    /* skip format */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkFormatProperties2(dec, pFormatProperties);
+    } else {
+        pFormatProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pImageFormatInfo);
+    if (pImageFormatInfo)
+        cmd_size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2(pImageFormatInfo);
+    cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
+    if (pImageFormatProperties)
+        cmd_size += vn_sizeof_VkImageFormatProperties2_partial(pImageFormatProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pImageFormatInfo))
+        vn_encode_VkPhysicalDeviceImageFormatInfo2(enc, pImageFormatInfo);
+    if (vn_encode_simple_pointer(enc, pImageFormatProperties))
+        vn_encode_VkImageFormatProperties2_partial(enc, pImageFormatProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip physicalDevice */
+    /* skip pImageFormatInfo */
+    cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
+    if (pImageFormatProperties)
+        cmd_size += vn_sizeof_VkImageFormatProperties2(pImageFormatProperties);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip physicalDevice */
+    /* skip pImageFormatInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkImageFormatProperties2(dec, pImageFormatProperties);
+    } else {
+        pImageFormatProperties = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
+    if (pQueueFamilyPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
+    if (pQueueFamilyProperties) {
+        cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount);
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
+            cmd_size += vn_sizeof_VkQueueFamilyProperties2_partial(&pQueueFamilyProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
+        vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
+    if (pQueueFamilyProperties) {
+        vn_encode_array_size(enc, *pQueueFamilyPropertyCount);
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
+            vn_encode_VkQueueFamilyProperties2_partial(enc, &pQueueFamilyProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
+    if (pQueueFamilyPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
+    if (pQueueFamilyProperties) {
+        cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount);
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
+            cmd_size += vn_sizeof_VkQueueFamilyProperties2(&pQueueFamilyProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT);
+
+    /* skip physicalDevice */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
+    } else {
+        pQueueFamilyPropertyCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pQueueFamilyPropertyCount);
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++)
+            vn_decode_VkQueueFamilyProperties2(dec, &pQueueFamilyProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pQueueFamilyProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
+    if (pMemoryProperties)
+        cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(pMemoryProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pMemoryProperties))
+        vn_encode_VkPhysicalDeviceMemoryProperties2_partial(enc, pMemoryProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
+    if (pMemoryProperties)
+        cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2(pMemoryProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT);
+
+    /* skip physicalDevice */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkPhysicalDeviceMemoryProperties2(dec, pMemoryProperties);
+    } else {
+        pMemoryProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pFormatInfo);
+    if (pFormatInfo)
+        cmd_size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(pFormatInfo);
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkSparseImageFormatProperties2_partial(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pFormatInfo))
+        vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(enc, pFormatInfo);
+    if (vn_encode_simple_pointer(enc, pPropertyCount))
+        vn_encode_uint32_t(enc, pPropertyCount);
+    if (pProperties) {
+        vn_encode_array_size(enc, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_encode_VkSparseImageFormatProperties2_partial(enc, &pProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    /* skip pFormatInfo */
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkSparseImageFormatProperties2(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT);
+
+    /* skip physicalDevice */
+    /* skip pFormatInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pPropertyCount);
+    } else {
+        pPropertyCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_decode_VkSparseImageFormatProperties2(dec, &pProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pExternalBufferInfo);
+    if (pExternalBufferInfo)
+        cmd_size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo(pExternalBufferInfo);
+    cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
+    if (pExternalBufferProperties)
+        cmd_size += vn_sizeof_VkExternalBufferProperties_partial(pExternalBufferProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pExternalBufferInfo))
+        vn_encode_VkPhysicalDeviceExternalBufferInfo(enc, pExternalBufferInfo);
+    if (vn_encode_simple_pointer(enc, pExternalBufferProperties))
+        vn_encode_VkExternalBufferProperties_partial(enc, pExternalBufferProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    /* skip pExternalBufferInfo */
+    cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
+    if (pExternalBufferProperties)
+        cmd_size += vn_sizeof_VkExternalBufferProperties(pExternalBufferProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT);
+
+    /* skip physicalDevice */
+    /* skip pExternalBufferInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkExternalBufferProperties(dec, pExternalBufferProperties);
+    } else {
+        pExternalBufferProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreInfo);
+    if (pExternalSemaphoreInfo)
+        cmd_size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(pExternalSemaphoreInfo);
+    cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
+    if (pExternalSemaphoreProperties)
+        cmd_size += vn_sizeof_VkExternalSemaphoreProperties_partial(pExternalSemaphoreProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pExternalSemaphoreInfo))
+        vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(enc, pExternalSemaphoreInfo);
+    if (vn_encode_simple_pointer(enc, pExternalSemaphoreProperties))
+        vn_encode_VkExternalSemaphoreProperties_partial(enc, pExternalSemaphoreProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    /* skip pExternalSemaphoreInfo */
+    cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
+    if (pExternalSemaphoreProperties)
+        cmd_size += vn_sizeof_VkExternalSemaphoreProperties(pExternalSemaphoreProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT);
+
+    /* skip physicalDevice */
+    /* skip pExternalSemaphoreInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkExternalSemaphoreProperties(dec, pExternalSemaphoreProperties);
+    } else {
+        pExternalSemaphoreProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
+    cmd_size += vn_sizeof_simple_pointer(pExternalFenceInfo);
+    if (pExternalFenceInfo)
+        cmd_size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo(pExternalFenceInfo);
+    cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
+    if (pExternalFenceProperties)
+        cmd_size += vn_sizeof_VkExternalFenceProperties_partial(pExternalFenceProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkPhysicalDevice(enc, &physicalDevice);
+    if (vn_encode_simple_pointer(enc, pExternalFenceInfo))
+        vn_encode_VkPhysicalDeviceExternalFenceInfo(enc, pExternalFenceInfo);
+    if (vn_encode_simple_pointer(enc, pExternalFenceProperties))
+        vn_encode_VkExternalFenceProperties_partial(enc, pExternalFenceProperties);
+}
+
+static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip physicalDevice */
+    /* skip pExternalFenceInfo */
+    cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
+    if (pExternalFenceProperties)
+        cmd_size += vn_sizeof_VkExternalFenceProperties(pExternalFenceProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT);
+
+    /* skip physicalDevice */
+    /* skip pExternalFenceInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkExternalFenceProperties(dec, pExternalFenceProperties);
+    } else {
+        pExternalFenceProperties = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkInstance(&instance);
+    cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
+    if (pPhysicalDeviceGroupCount)
+        cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
+    if (pPhysicalDeviceGroupProperties) {
+        cmd_size += vn_sizeof_array_size(*pPhysicalDeviceGroupCount);
+        for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++)
+            cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties_partial(&pPhysicalDeviceGroupProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkInstance(enc, &instance);
+    if (vn_encode_simple_pointer(enc, pPhysicalDeviceGroupCount))
+        vn_encode_uint32_t(enc, pPhysicalDeviceGroupCount);
+    if (pPhysicalDeviceGroupProperties) {
+        vn_encode_array_size(enc, *pPhysicalDeviceGroupCount);
+        for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++)
+            vn_encode_VkPhysicalDeviceGroupProperties_partial(enc, &pPhysicalDeviceGroupProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip instance */
+    cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
+    if (pPhysicalDeviceGroupCount)
+        cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
+    if (pPhysicalDeviceGroupProperties) {
+        cmd_size += vn_sizeof_array_size(*pPhysicalDeviceGroupCount);
+        for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++)
+            cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties(&pPhysicalDeviceGroupProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip instance */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pPhysicalDeviceGroupCount);
+    } else {
+        pPhysicalDeviceGroupCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pPhysicalDeviceGroupCount);
+        for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++)
+            vn_decode_VkPhysicalDeviceGroupProperties(dec, &pPhysicalDeviceGroupProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pPhysicalDeviceGroupProperties = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&heapIndex);
+    cmd_size += vn_sizeof_uint32_t(&localDeviceIndex);
+    cmd_size += vn_sizeof_uint32_t(&remoteDeviceIndex);
+    cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures); /* out */
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetDeviceGroupPeerMemoryFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &heapIndex);
+    vn_encode_uint32_t(enc, &localDeviceIndex);
+    vn_encode_uint32_t(enc, &remoteDeviceIndex);
+    vn_encode_simple_pointer(enc, pPeerMemoryFeatures); /* out */
+}
+
+static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip heapIndex */
+    /* skip localDeviceIndex */
+    /* skip remoteDeviceIndex */
+    cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures);
+    if (pPeerMemoryFeatures)
+        cmd_size += vn_sizeof_VkFlags(pPeerMemoryFeatures);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT);
+
+    /* skip device */
+    /* skip heapIndex */
+    /* skip localDeviceIndex */
+    /* skip remoteDeviceIndex */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkFlags(dec, pPeerMemoryFeatures);
+    } else {
+        pPeerMemoryFeatures = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pQueueInfo);
+    if (pQueueInfo)
+        cmd_size += vn_sizeof_VkDeviceQueueInfo2(pQueueInfo);
+    cmd_size += vn_sizeof_simple_pointer(pQueue);
+    if (pQueue)
+        cmd_size += vn_sizeof_VkQueue(pQueue);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pQueueInfo))
+        vn_encode_VkDeviceQueueInfo2(enc, pQueueInfo);
+    if (vn_encode_simple_pointer(enc, pQueue))
+        vn_encode_VkQueue(enc, pQueue);
+}
+
+static inline size_t vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pQueueInfo */
+    cmd_size += vn_sizeof_simple_pointer(pQueue);
+    if (pQueue)
+        cmd_size += vn_sizeof_VkQueue(pQueue);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT);
+
+    /* skip device */
+    /* skip pQueueInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkQueue(dec, pQueue);
+    } else {
+        pQueue = NULL;
+    }
+}
+
+static inline void vn_submit_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEnumeratePhysicalDevices(&submit->command, cmd_flags, instance, pPhysicalDeviceCount, pPhysicalDevices);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDevices_reply(instance, pPhysicalDeviceCount, pPhysicalDevices) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceProperties(&submit->command, cmd_flags, physicalDevice, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties_reply(physicalDevice, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(&submit->command, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceMemoryProperties(&submit->command, cmd_flags, physicalDevice, pMemoryProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(physicalDevice, pMemoryProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceFeatures(&submit->command, cmd_flags, physicalDevice, pFeatures);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures_reply(physicalDevice, pFeatures) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceFormatProperties(&submit->command, cmd_flags, physicalDevice, format, pFormatProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(physicalDevice, format, pFormatProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceImageFormatProperties(&submit->command, cmd_flags, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCreateDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateDevice(&submit->command, cmd_flags, physicalDevice, pCreateInfo, pAllocator, pDevice);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDevice_reply(physicalDevice, pCreateInfo, pAllocator, pDevice) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyDevice(device, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyDevice(&submit->command, cmd_flags, device, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDevice_reply(device, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEnumerateDeviceLayerProperties(&submit->command, cmd_flags, physicalDevice, pPropertyCount, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceLayerProperties_reply(physicalDevice, pPropertyCount, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEnumerateDeviceExtensionProperties(&submit->command, cmd_flags, physicalDevice, pLayerName, pPropertyCount, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(physicalDevice, pLayerName, pPropertyCount, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetDeviceQueue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetDeviceQueue(&submit->command, cmd_flags, device, queueFamilyIndex, queueIndex, pQueue);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue_reply(device, queueFamilyIndex, queueIndex, pQueue) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDeviceWaitIdle(device);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDeviceWaitIdle(&submit->command, cmd_flags, device);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDeviceWaitIdle_reply(device) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(&submit->command, cmd_flags, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceFeatures2(&submit->command, cmd_flags, physicalDevice, pFeatures);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(physicalDevice, pFeatures) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceProperties2(&submit->command, cmd_flags, physicalDevice, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties2_reply(physicalDevice, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceFormatProperties2(&submit->command, cmd_flags, physicalDevice, format, pFormatProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(physicalDevice, format, pFormatProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceImageFormatProperties2(&submit->command, cmd_flags, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(physicalDevice, pImageFormatInfo, pImageFormatProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(&submit->command, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceMemoryProperties2(&submit->command, cmd_flags, physicalDevice, pMemoryProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(physicalDevice, pMemoryProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(&submit->command, cmd_flags, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(physicalDevice, pFormatInfo, pPropertyCount, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceExternalBufferProperties(&submit->command, cmd_flags, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(&submit->command, cmd_flags, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPhysicalDeviceExternalFenceProperties(&submit->command, cmd_flags, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEnumeratePhysicalDeviceGroups(&submit->command, cmd_flags, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetDeviceGroupPeerMemoryFeatures(&submit->command, cmd_flags, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetDeviceQueue2(device, pQueueInfo, pQueue);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetDeviceQueue2(&submit->command, cmd_flags, device, pQueueInfo, pQueue);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue2_reply(device, pQueueInfo, pQueue) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumeratePhysicalDevices(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEnumeratePhysicalDevices_reply(&submit.reply, instance, pPhysicalDeviceCount, pPhysicalDevices);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumeratePhysicalDevices(vn_instance, 0, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceProperties_reply(&submit.reply, physicalDevice, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceProperties(vn_instance, 0, physicalDevice, pProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(&submit.reply, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(&submit.reply, physicalDevice, pMemoryProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, 0, physicalDevice, pMemoryProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceFeatures_reply(&submit.reply, physicalDevice, pFeatures);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, 0, physicalDevice, pFeatures, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceFormatProperties_reply(&submit.reply, physicalDevice, format, pFormatProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit);
+}
+
+static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(&submit.reply, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, 0, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
+}
+
+static inline VkResult vn_call_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateDevice_reply(&submit.reply, physicalDevice, pCreateInfo, pAllocator, pDevice);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDevice(vn_instance, 0, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
+}
+
+static inline void vn_call_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyDevice_reply(&submit.reply, device, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDevice(vn_instance, 0, device, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pPropertyCount, pProperties, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEnumerateDeviceLayerProperties_reply(&submit.reply, physicalDevice, pPropertyCount, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, 0, physicalDevice, pPropertyCount, pProperties, &submit);
+}
+
+static inline VkResult vn_call_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEnumerateDeviceExtensionProperties_reply(&submit.reply, physicalDevice, pLayerName, pPropertyCount, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, 0, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
+}
+
+static inline void vn_call_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDeviceQueue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queueFamilyIndex, queueIndex, pQueue, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetDeviceQueue_reply(&submit.reply, device, queueFamilyIndex, queueIndex, pQueue);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDeviceQueue(vn_instance, 0, device, queueFamilyIndex, queueIndex, pQueue, &submit);
+}
+
+static inline VkResult vn_call_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDeviceWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkDeviceWaitIdle_reply(&submit.reply, device);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDeviceWaitIdle(vn_instance, 0, device, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(&submit.reply, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, 0, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceFeatures2_reply(&submit.reply, physicalDevice, pFeatures);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, 0, physicalDevice, pFeatures, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceProperties2_reply(&submit.reply, physicalDevice, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, 0, physicalDevice, pProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(&submit.reply, physicalDevice, format, pFormatProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit);
+}
+
+static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(&submit.reply, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, 0, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(&submit.reply, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(&submit.reply, physicalDevice, pMemoryProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, 0, physicalDevice, pMemoryProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(&submit.reply, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, 0, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(&submit.reply, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, 0, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(&submit.reply, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, 0, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
+}
+
+static inline void vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(&submit.reply, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, 0, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
+}
+
+static inline VkResult vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEnumeratePhysicalDeviceGroups_reply(&submit.reply, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, 0, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
+}
+
+static inline void vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(&submit.reply, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, 0, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
+}
+
+static inline void vn_call_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDeviceQueue2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pQueueInfo, pQueue, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetDeviceQueue2_reply(&submit.reply, device, pQueueInfo, pQueue);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDeviceQueue2(vn_instance, 0, device, pQueueInfo, pQueue, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_DEVICE_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_device_memory.h b/src/virtio/venus-protocol/vn_protocol_driver_device_memory.h
new file mode 100644 (file)
index 0000000..f437a60
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_device_memory.h
@@ -0,0 +1,1204 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_DEVICE_MEMORY_H
+#define VN_PROTOCOL_DRIVER_DEVICE_MEMORY_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/*
+ * These structs/unions/commands are not included
+ *
+ *   vkMapMemory
+ */
+
+/* struct VkExportMemoryAllocateInfo chain */
+
+static inline size_t
+vn_sizeof_VkExportMemoryAllocateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExportMemoryAllocateInfo_self(const VkExportMemoryAllocateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->handleTypes);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExportMemoryAllocateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkExportMemoryAllocateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExportMemoryAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExportMemoryAllocateInfo_self(struct vn_cs_encoder *enc, const VkExportMemoryAllocateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->handleTypes);
+}
+
+static inline void
+vn_encode_VkExportMemoryAllocateInfo(struct vn_cs_encoder *enc, const VkExportMemoryAllocateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO });
+    vn_encode_VkExportMemoryAllocateInfo_pnext(enc, val->pNext);
+    vn_encode_VkExportMemoryAllocateInfo_self(enc, val);
+}
+
+/* struct VkMemoryAllocateFlagsInfo chain */
+
+static inline size_t
+vn_sizeof_VkMemoryAllocateFlagsInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkMemoryAllocateFlagsInfo_self(const VkMemoryAllocateFlagsInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->deviceMask);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkMemoryAllocateFlagsInfo_pnext(val->pNext);
+    size += vn_sizeof_VkMemoryAllocateFlagsInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkMemoryAllocateFlagsInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkMemoryAllocateFlagsInfo_self(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagsInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->deviceMask);
+}
+
+static inline void
+vn_encode_VkMemoryAllocateFlagsInfo(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagsInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO });
+    vn_encode_VkMemoryAllocateFlagsInfo_pnext(enc, val->pNext);
+    vn_encode_VkMemoryAllocateFlagsInfo_self(enc, val);
+}
+
+/* struct VkMemoryDedicatedAllocateInfo chain */
+
+static inline size_t
+vn_sizeof_VkMemoryDedicatedAllocateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkMemoryDedicatedAllocateInfo_self(const VkMemoryDedicatedAllocateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkImage(&val->image);
+    size += vn_sizeof_VkBuffer(&val->buffer);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkMemoryDedicatedAllocateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkMemoryDedicatedAllocateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkMemoryDedicatedAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkMemoryDedicatedAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryDedicatedAllocateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkImage(enc, &val->image);
+    vn_encode_VkBuffer(enc, &val->buffer);
+}
+
+static inline void
+vn_encode_VkMemoryDedicatedAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryDedicatedAllocateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO });
+    vn_encode_VkMemoryDedicatedAllocateInfo_pnext(enc, val->pNext);
+    vn_encode_VkMemoryDedicatedAllocateInfo_self(enc, val);
+}
+
+/* struct VkMemoryOpaqueCaptureAddressAllocateInfo chain */
+
+static inline size_t
+vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self(const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint64_t(&val->opaqueCaptureAddress);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint64_t(enc, &val->opaqueCaptureAddress);
+}
+
+static inline void
+vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO });
+    vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(enc, val->pNext);
+    vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(enc, val);
+}
+
+/* struct VkMemoryAllocateInfo chain */
+
+static inline size_t
+vn_sizeof_VkMemoryAllocateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkExportMemoryAllocateInfo_self((const VkExportMemoryAllocateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkMemoryAllocateFlagsInfo_self((const VkMemoryAllocateFlagsInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkMemoryDedicatedAllocateInfo_self((const VkMemoryDedicatedAllocateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self((const VkMemoryOpaqueCaptureAddressAllocateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkMemoryAllocateInfo_self(const VkMemoryAllocateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDeviceSize(&val->allocationSize);
+    size += vn_sizeof_uint32_t(&val->memoryTypeIndex);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkMemoryAllocateInfo(const VkMemoryAllocateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkMemoryAllocateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkMemoryAllocateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkMemoryAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkExportMemoryAllocateInfo_self(enc, (const VkExportMemoryAllocateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkMemoryAllocateFlagsInfo_self(enc, (const VkMemoryAllocateFlagsInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkMemoryDedicatedAllocateInfo_self(enc, (const VkMemoryDedicatedAllocateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(enc, (const VkMemoryOpaqueCaptureAddressAllocateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkMemoryAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryAllocateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkDeviceSize(enc, &val->allocationSize);
+    vn_encode_uint32_t(enc, &val->memoryTypeIndex);
+}
+
+static inline void
+vn_encode_VkMemoryAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryAllocateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO });
+    vn_encode_VkMemoryAllocateInfo_pnext(enc, val->pNext);
+    vn_encode_VkMemoryAllocateInfo_self(enc, val);
+}
+
+/* struct VkMappedMemoryRange chain */
+
+static inline size_t
+vn_sizeof_VkMappedMemoryRange_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkMappedMemoryRange_self(const VkMappedMemoryRange *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDeviceMemory(&val->memory);
+    size += vn_sizeof_VkDeviceSize(&val->offset);
+    size += vn_sizeof_VkDeviceSize(&val->size);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkMappedMemoryRange(const VkMappedMemoryRange *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkMappedMemoryRange_pnext(val->pNext);
+    size += vn_sizeof_VkMappedMemoryRange_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkMappedMemoryRange_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkMappedMemoryRange_self(struct vn_cs_encoder *enc, const VkMappedMemoryRange *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkDeviceMemory(enc, &val->memory);
+    vn_encode_VkDeviceSize(enc, &val->offset);
+    vn_encode_VkDeviceSize(enc, &val->size);
+}
+
+static inline void
+vn_encode_VkMappedMemoryRange(struct vn_cs_encoder *enc, const VkMappedMemoryRange *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE });
+    vn_encode_VkMappedMemoryRange_pnext(enc, val->pNext);
+    vn_encode_VkMappedMemoryRange_self(enc, val);
+}
+
+static inline void
+vn_decode_VkMappedMemoryRange_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkMappedMemoryRange_self(struct vn_cs_decoder *dec, VkMappedMemoryRange *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkDeviceMemory(dec, &val->memory);
+    vn_decode_VkDeviceSize(dec, &val->offset);
+    vn_decode_VkDeviceSize(dec, &val->size);
+}
+
+static inline void
+vn_decode_VkMappedMemoryRange(struct vn_cs_decoder *dec, VkMappedMemoryRange *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE);
+
+    assert(val->sType == stype);
+    vn_decode_VkMappedMemoryRange_pnext(dec, val->pNext);
+    vn_decode_VkMappedMemoryRange_self(dec, val);
+}
+
+/* struct VkDeviceMemoryOpaqueCaptureAddressInfo chain */
+
+static inline size_t
+vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_self(const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDeviceMemory(&val->memory);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(struct vn_cs_encoder *enc, const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkDeviceMemory(enc, &val->memory);
+}
+
+static inline void
+vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo(struct vn_cs_encoder *enc, const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO });
+    vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(enc, val->pNext);
+    vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(struct vn_cs_decoder *dec, VkDeviceMemoryOpaqueCaptureAddressInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkDeviceMemory(dec, &val->memory);
+}
+
+static inline void
+vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo(struct vn_cs_decoder *dec, VkDeviceMemoryOpaqueCaptureAddressInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(dec, val->pNext);
+    vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(dec, val);
+}
+
+static inline size_t vn_sizeof_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pAllocateInfo);
+    if (pAllocateInfo)
+        cmd_size += vn_sizeof_VkMemoryAllocateInfo(pAllocateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pMemory);
+    if (pMemory)
+        cmd_size += vn_sizeof_VkDeviceMemory(pMemory);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkAllocateMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pAllocateInfo))
+        vn_encode_VkMemoryAllocateInfo(enc, pAllocateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pMemory))
+        vn_encode_VkDeviceMemory(enc, pMemory);
+}
+
+static inline size_t vn_sizeof_vkAllocateMemory_reply(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pAllocateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pMemory);
+    if (pMemory)
+        cmd_size += vn_sizeof_VkDeviceMemory(pMemory);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkAllocateMemory_reply(struct vn_cs_decoder *dec, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkAllocateMemory_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pAllocateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDeviceMemory(dec, pMemory);
+    } else {
+        pMemory = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkFreeMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDeviceMemory(enc, &memory);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkFreeMemory_reply(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip memory */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkFreeMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkFreeMemory_EXT);
+
+    /* skip device */
+    /* skip memory */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkUnmapMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDeviceMemory(enc, &memory);
+}
+
+static inline size_t vn_sizeof_vkUnmapMemory_reply(VkDevice device, VkDeviceMemory memory)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip memory */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkUnmapMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkUnmapMemory_EXT);
+
+    /* skip device */
+    /* skip memory */
+}
+
+static inline size_t vn_sizeof_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&memoryRangeCount);
+    if (pMemoryRanges) {
+        cmd_size += vn_sizeof_array_size(memoryRangeCount);
+        for (uint32_t i = 0; i < memoryRangeCount; i++)
+            cmd_size += vn_sizeof_VkMappedMemoryRange(&pMemoryRanges[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkFlushMappedMemoryRanges(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &memoryRangeCount);
+    if (pMemoryRanges) {
+        vn_encode_array_size(enc, memoryRangeCount);
+        for (uint32_t i = 0; i < memoryRangeCount; i++)
+            vn_encode_VkMappedMemoryRange(enc, &pMemoryRanges[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkFlushMappedMemoryRanges_reply(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip memoryRangeCount */
+    /* skip pMemoryRanges */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkFlushMappedMemoryRanges_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip memoryRangeCount */
+    /* skip pMemoryRanges */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&memoryRangeCount);
+    if (pMemoryRanges) {
+        cmd_size += vn_sizeof_array_size(memoryRangeCount);
+        for (uint32_t i = 0; i < memoryRangeCount; i++)
+            cmd_size += vn_sizeof_VkMappedMemoryRange(&pMemoryRanges[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkInvalidateMappedMemoryRanges(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &memoryRangeCount);
+    if (pMemoryRanges) {
+        vn_encode_array_size(enc, memoryRangeCount);
+        for (uint32_t i = 0; i < memoryRangeCount; i++)
+            vn_encode_VkMappedMemoryRange(enc, &pMemoryRanges[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkInvalidateMappedMemoryRanges_reply(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip memoryRangeCount */
+    /* skip pMemoryRanges */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkInvalidateMappedMemoryRanges_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip memoryRangeCount */
+    /* skip pMemoryRanges */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
+    cmd_size += vn_sizeof_simple_pointer(pCommittedMemoryInBytes); /* out */
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetDeviceMemoryCommitment(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDeviceMemory(enc, &memory);
+    vn_encode_simple_pointer(enc, pCommittedMemoryInBytes); /* out */
+}
+
+static inline size_t vn_sizeof_vkGetDeviceMemoryCommitment_reply(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip memory */
+    cmd_size += vn_sizeof_simple_pointer(pCommittedMemoryInBytes);
+    if (pCommittedMemoryInBytes)
+        cmd_size += vn_sizeof_VkDeviceSize(pCommittedMemoryInBytes);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetDeviceMemoryCommitment_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT);
+
+    /* skip device */
+    /* skip memory */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDeviceSize(dec, pCommittedMemoryInBytes);
+    } else {
+        pCommittedMemoryInBytes = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pInfo);
+    if (pInfo)
+        cmd_size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo(pInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pInfo))
+        vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo(enc, pInfo);
+}
+
+static inline size_t vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    uint64_t ret;
+    cmd_size += vn_sizeof_uint64_t(&ret);
+    /* skip device */
+    /* skip pInfo */
+
+    return cmd_size;
+}
+
+static inline uint64_t vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT);
+
+    uint64_t ret;
+    vn_decode_uint64_t(dec, &ret);
+    /* skip device */
+    /* skip pInfo */
+
+    return ret;
+}
+
+static inline void vn_submit_vkAllocateMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkAllocateMemory(&submit->command, cmd_flags, device, pAllocateInfo, pAllocator, pMemory);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateMemory_reply(device, pAllocateInfo, pAllocator, pMemory) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkFreeMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkFreeMemory(device, memory, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkFreeMemory(&submit->command, cmd_flags, device, memory, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeMemory_reply(device, memory, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkUnmapMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkUnmapMemory(device, memory);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkUnmapMemory(&submit->command, cmd_flags, device, memory);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUnmapMemory_reply(device, memory) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkFlushMappedMemoryRanges(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkFlushMappedMemoryRanges(&submit->command, cmd_flags, device, memoryRangeCount, pMemoryRanges);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFlushMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkInvalidateMappedMemoryRanges(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkInvalidateMappedMemoryRanges(&submit->command, cmd_flags, device, memoryRangeCount, pMemoryRanges);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkInvalidateMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetDeviceMemoryCommitment(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetDeviceMemoryCommitment(&submit->command, cmd_flags, device, memory, pCommittedMemoryInBytes);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryCommitment_reply(device, memory, pCommittedMemoryInBytes) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(&submit->command, cmd_flags, device, pInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(device, pInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkAllocateMemory(struct vn_instance *vn_instance, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkAllocateMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pAllocator, pMemory, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkAllocateMemory_reply(&submit.reply, device, pAllocateInfo, pAllocator, pMemory);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkAllocateMemory(struct vn_instance *vn_instance, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkAllocateMemory(vn_instance, 0, device, pAllocateInfo, pAllocator, pMemory, &submit);
+}
+
+static inline void vn_call_vkFreeMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkFreeMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkFreeMemory_reply(&submit.reply, device, memory, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkFreeMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkFreeMemory(vn_instance, 0, device, memory, pAllocator, &submit);
+}
+
+static inline void vn_call_vkUnmapMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkUnmapMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkUnmapMemory_reply(&submit.reply, device, memory);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkUnmapMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkUnmapMemory(vn_instance, 0, device, memory, &submit);
+}
+
+static inline VkResult vn_call_vkFlushMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkFlushMappedMemoryRanges(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memoryRangeCount, pMemoryRanges, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkFlushMappedMemoryRanges_reply(&submit.reply, device, memoryRangeCount, pMemoryRanges);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkFlushMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkFlushMappedMemoryRanges(vn_instance, 0, device, memoryRangeCount, pMemoryRanges, &submit);
+}
+
+static inline VkResult vn_call_vkInvalidateMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkInvalidateMappedMemoryRanges(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memoryRangeCount, pMemoryRanges, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkInvalidateMappedMemoryRanges_reply(&submit.reply, device, memoryRangeCount, pMemoryRanges);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkInvalidateMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkInvalidateMappedMemoryRanges(vn_instance, 0, device, memoryRangeCount, pMemoryRanges, &submit);
+}
+
+static inline void vn_call_vkGetDeviceMemoryCommitment(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDeviceMemoryCommitment(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, pCommittedMemoryInBytes, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetDeviceMemoryCommitment_reply(&submit.reply, device, memory, pCommittedMemoryInBytes);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetDeviceMemoryCommitment(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDeviceMemoryCommitment(vn_instance, 0, device, memory, pCommittedMemoryInBytes, &submit);
+}
+
+static inline uint64_t vn_call_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit);
+    if (submit.reply_bo) {
+        const uint64_t ret = vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(&submit.reply, device, pInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(vn_instance, 0, device, pInfo, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_DEVICE_MEMORY_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_event.h b/src/virtio/venus-protocol/vn_protocol_driver_event.h
new file mode 100644 (file)
index 0000000..292e99e
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_event.h
@@ -0,0 +1,538 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_EVENT_H
+#define VN_PROTOCOL_DRIVER_EVENT_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkEventCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkEventCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkEventCreateInfo_self(const VkEventCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkEventCreateInfo(const VkEventCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkEventCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkEventCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkEventCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkEventCreateInfo_self(struct vn_cs_encoder *enc, const VkEventCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+}
+
+static inline void
+vn_encode_VkEventCreateInfo(struct vn_cs_encoder *enc, const VkEventCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO });
+    vn_encode_VkEventCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkEventCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkEventCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pEvent);
+    if (pEvent)
+        cmd_size += vn_sizeof_VkEvent(pEvent);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkEventCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pEvent))
+        vn_encode_VkEvent(enc, pEvent);
+}
+
+static inline size_t vn_sizeof_vkCreateEvent_reply(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pEvent);
+    if (pEvent)
+        cmd_size += vn_sizeof_VkEvent(pEvent);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateEvent_reply(struct vn_cs_decoder *dec, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateEvent_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkEvent(dec, pEvent);
+    } else {
+        pEvent = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkEvent(&event);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkEvent(enc, &event);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyEvent_reply(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip event */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyEvent_EXT);
+
+    /* skip device */
+    /* skip event */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetEventStatus(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkEvent(&event);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetEventStatus(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkEvent(enc, &event);
+}
+
+static inline size_t vn_sizeof_vkGetEventStatus_reply(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip event */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetEventStatus_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetEventStatus_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip event */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkSetEvent(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkEvent(&event);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkSetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkEvent(enc, &event);
+}
+
+static inline size_t vn_sizeof_vkSetEvent_reply(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip event */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkSetEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkSetEvent_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip event */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkResetEvent(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkEvent(&event);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkEvent(enc, &event);
+}
+
+static inline size_t vn_sizeof_vkResetEvent_reply(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip event */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkResetEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetEvent_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip event */
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateEvent(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pEvent);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateEvent_reply(device, pCreateInfo, pAllocator, pEvent) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyEvent(device, event, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyEvent(&submit->command, cmd_flags, device, event, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyEvent_reply(device, event, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetEventStatus(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetEventStatus(device, event);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetEventStatus(&submit->command, cmd_flags, device, event);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetEventStatus_reply(device, event) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkSetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkSetEvent(device, event);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkSetEvent(&submit->command, cmd_flags, device, event);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetEvent_reply(device, event) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetEvent(device, event);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetEvent(&submit->command, cmd_flags, device, event);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetEvent_reply(device, event) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateEvent(struct vn_instance *vn_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pEvent, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateEvent_reply(&submit.reply, device, pCreateInfo, pAllocator, pEvent);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateEvent(struct vn_instance *vn_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateEvent(vn_instance, 0, device, pCreateInfo, pAllocator, pEvent, &submit);
+}
+
+static inline void vn_call_vkDestroyEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyEvent_reply(&submit.reply, device, event, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyEvent(vn_instance, 0, device, event, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkGetEventStatus(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetEventStatus(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetEventStatus_reply(&submit.reply, device, event);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetEventStatus(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetEventStatus(vn_instance, 0, device, event, &submit);
+}
+
+static inline VkResult vn_call_vkSetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkSetEvent_reply(&submit.reply, device, event);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkSetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSetEvent(vn_instance, 0, device, event, &submit);
+}
+
+static inline VkResult vn_call_vkResetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkResetEvent_reply(&submit.reply, device, event);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkResetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetEvent(vn_instance, 0, device, event, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_EVENT_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_fence.h b/src/virtio/venus-protocol/vn_protocol_driver_fence.h
new file mode 100644 (file)
index 0000000..4026210
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_fence.h
@@ -0,0 +1,664 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_FENCE_H
+#define VN_PROTOCOL_DRIVER_FENCE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkExportFenceCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkExportFenceCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExportFenceCreateInfo_self(const VkExportFenceCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->handleTypes);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExportFenceCreateInfo(const VkExportFenceCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExportFenceCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkExportFenceCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExportFenceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExportFenceCreateInfo_self(struct vn_cs_encoder *enc, const VkExportFenceCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->handleTypes);
+}
+
+static inline void
+vn_encode_VkExportFenceCreateInfo(struct vn_cs_encoder *enc, const VkExportFenceCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO });
+    vn_encode_VkExportFenceCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkExportFenceCreateInfo_self(enc, val);
+}
+
+/* struct VkFenceCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkFenceCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkFenceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkExportFenceCreateInfo_self((const VkExportFenceCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkFenceCreateInfo_self(const VkFenceCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkFenceCreateInfo(const VkFenceCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkFenceCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkFenceCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkFenceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkFenceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkExportFenceCreateInfo_self(enc, (const VkExportFenceCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkFenceCreateInfo_self(struct vn_cs_encoder *enc, const VkFenceCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+}
+
+static inline void
+vn_encode_VkFenceCreateInfo(struct vn_cs_encoder *enc, const VkFenceCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO });
+    vn_encode_VkFenceCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkFenceCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkFenceCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pFence);
+    if (pFence)
+        cmd_size += vn_sizeof_VkFence(pFence);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateFence(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkFenceCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pFence))
+        vn_encode_VkFence(enc, pFence);
+}
+
+static inline size_t vn_sizeof_vkCreateFence_reply(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pFence);
+    if (pFence)
+        cmd_size += vn_sizeof_VkFence(pFence);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateFence_reply(struct vn_cs_decoder *dec, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateFence_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkFence(dec, pFence);
+    } else {
+        pFence = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkFence(&fence);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyFence(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkFence(enc, &fence);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyFence_reply(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip fence */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyFence_reply(struct vn_cs_decoder *dec, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyFence_EXT);
+
+    /* skip device */
+    /* skip fence */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&fenceCount);
+    if (pFences) {
+        cmd_size += vn_sizeof_array_size(fenceCount);
+        for (uint32_t i = 0; i < fenceCount; i++)
+            cmd_size += vn_sizeof_VkFence(&pFences[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetFences(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &fenceCount);
+    if (pFences) {
+        vn_encode_array_size(enc, fenceCount);
+        for (uint32_t i = 0; i < fenceCount; i++)
+            vn_encode_VkFence(enc, &pFences[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkResetFences_reply(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip fenceCount */
+    /* skip pFences */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkResetFences_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetFences_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip fenceCount */
+    /* skip pFences */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetFenceStatus(VkDevice device, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkFence(&fence);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetFenceStatus(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkFence(enc, &fence);
+}
+
+static inline size_t vn_sizeof_vkGetFenceStatus_reply(VkDevice device, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip fence */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetFenceStatus_reply(struct vn_cs_decoder *dec, VkDevice device, VkFence fence)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetFenceStatus_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip fence */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&fenceCount);
+    if (pFences) {
+        cmd_size += vn_sizeof_array_size(fenceCount);
+        for (uint32_t i = 0; i < fenceCount; i++)
+            cmd_size += vn_sizeof_VkFence(&pFences[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_VkBool32(&waitAll);
+    cmd_size += vn_sizeof_uint64_t(&timeout);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkWaitForFences(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &fenceCount);
+    if (pFences) {
+        vn_encode_array_size(enc, fenceCount);
+        for (uint32_t i = 0; i < fenceCount; i++)
+            vn_encode_VkFence(enc, &pFences[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkBool32(enc, &waitAll);
+    vn_encode_uint64_t(enc, &timeout);
+}
+
+static inline size_t vn_sizeof_vkWaitForFences_reply(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip fenceCount */
+    /* skip pFences */
+    /* skip waitAll */
+    /* skip timeout */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkWaitForFences_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkWaitForFences_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip fenceCount */
+    /* skip pFences */
+    /* skip waitAll */
+    /* skip timeout */
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateFence(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateFence(device, pCreateInfo, pAllocator, pFence);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateFence(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pFence);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFence_reply(device, pCreateInfo, pAllocator, pFence) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyFence(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyFence(device, fence, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyFence(&submit->command, cmd_flags, device, fence, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFence_reply(device, fence, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetFences(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetFences(device, fenceCount, pFences);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetFences(&submit->command, cmd_flags, device, fenceCount, pFences);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetFences_reply(device, fenceCount, pFences) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetFenceStatus(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetFenceStatus(device, fence);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetFenceStatus(&submit->command, cmd_flags, device, fence);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetFenceStatus_reply(device, fence) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkWaitForFences(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkWaitForFences(&submit->command, cmd_flags, device, fenceCount, pFences, waitAll, timeout);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitForFences_reply(device, fenceCount, pFences, waitAll, timeout) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateFence(struct vn_instance *vn_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateFence(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pFence, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateFence_reply(&submit.reply, device, pCreateInfo, pAllocator, pFence);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateFence(struct vn_instance *vn_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateFence(vn_instance, 0, device, pCreateInfo, pAllocator, pFence, &submit);
+}
+
+static inline void vn_call_vkDestroyFence(struct vn_instance *vn_instance, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyFence(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyFence_reply(&submit.reply, device, fence, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyFence(struct vn_instance *vn_instance, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyFence(vn_instance, 0, device, fence, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkResetFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetFences(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fenceCount, pFences, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkResetFences_reply(&submit.reply, device, fenceCount, pFences);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkResetFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetFences(vn_instance, 0, device, fenceCount, pFences, &submit);
+}
+
+static inline VkResult vn_call_vkGetFenceStatus(struct vn_instance *vn_instance, VkDevice device, VkFence fence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetFenceStatus(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetFenceStatus_reply(&submit.reply, device, fence);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetFenceStatus(struct vn_instance *vn_instance, VkDevice device, VkFence fence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetFenceStatus(vn_instance, 0, device, fence, &submit);
+}
+
+static inline VkResult vn_call_vkWaitForFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWaitForFences(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fenceCount, pFences, waitAll, timeout, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkWaitForFences_reply(&submit.reply, device, fenceCount, pFences, waitAll, timeout);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkWaitForFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWaitForFences(vn_instance, 0, device, fenceCount, pFences, waitAll, timeout, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_FENCE_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_framebuffer.h b/src/virtio/venus-protocol/vn_protocol_driver_framebuffer.h
new file mode 100644 (file)
index 0000000..42d6fae
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_framebuffer.h
@@ -0,0 +1,467 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_FRAMEBUFFER_H
+#define VN_PROTOCOL_DRIVER_FRAMEBUFFER_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkFramebufferAttachmentImageInfo chain */
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentImageInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentImageInfo_self(const VkFramebufferAttachmentImageInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkFlags(&val->usage);
+    size += vn_sizeof_uint32_t(&val->width);
+    size += vn_sizeof_uint32_t(&val->height);
+    size += vn_sizeof_uint32_t(&val->layerCount);
+    size += vn_sizeof_uint32_t(&val->viewFormatCount);
+    if (val->pViewFormats) {
+        size += vn_sizeof_array_size(val->viewFormatCount);
+        size += vn_sizeof_VkFormat_array(val->pViewFormats, val->viewFormatCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkFramebufferAttachmentImageInfo_pnext(val->pNext);
+    size += vn_sizeof_VkFramebufferAttachmentImageInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentImageInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentImageInfo_self(struct vn_cs_encoder *enc, const VkFramebufferAttachmentImageInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkFlags(enc, &val->usage);
+    vn_encode_uint32_t(enc, &val->width);
+    vn_encode_uint32_t(enc, &val->height);
+    vn_encode_uint32_t(enc, &val->layerCount);
+    vn_encode_uint32_t(enc, &val->viewFormatCount);
+    if (val->pViewFormats) {
+        vn_encode_array_size(enc, val->viewFormatCount);
+        vn_encode_VkFormat_array(enc, val->pViewFormats, val->viewFormatCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentImageInfo(struct vn_cs_encoder *enc, const VkFramebufferAttachmentImageInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO });
+    vn_encode_VkFramebufferAttachmentImageInfo_pnext(enc, val->pNext);
+    vn_encode_VkFramebufferAttachmentImageInfo_self(enc, val);
+}
+
+/* struct VkFramebufferAttachmentsCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentsCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentsCreateInfo_self(const VkFramebufferAttachmentsCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->attachmentImageInfoCount);
+    if (val->pAttachmentImageInfos) {
+        size += vn_sizeof_array_size(val->attachmentImageInfoCount);
+        for (uint32_t i = 0; i < val->attachmentImageInfoCount; i++)
+            size += vn_sizeof_VkFramebufferAttachmentImageInfo(&val->pAttachmentImageInfos[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentsCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentsCreateInfo_self(struct vn_cs_encoder *enc, const VkFramebufferAttachmentsCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->attachmentImageInfoCount);
+    if (val->pAttachmentImageInfos) {
+        vn_encode_array_size(enc, val->attachmentImageInfoCount);
+        for (uint32_t i = 0; i < val->attachmentImageInfoCount; i++)
+            vn_encode_VkFramebufferAttachmentImageInfo(enc, &val->pAttachmentImageInfos[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentsCreateInfo(struct vn_cs_encoder *enc, const VkFramebufferAttachmentsCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO });
+    vn_encode_VkFramebufferAttachmentsCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkFramebufferAttachmentsCreateInfo_self(enc, val);
+}
+
+/* struct VkFramebufferCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkFramebufferCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkFramebufferCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_self((const VkFramebufferAttachmentsCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferCreateInfo_self(const VkFramebufferCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkRenderPass(&val->renderPass);
+    size += vn_sizeof_uint32_t(&val->attachmentCount);
+    if (val->pAttachments) {
+        size += vn_sizeof_array_size(val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            size += vn_sizeof_VkImageView(&val->pAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->width);
+    size += vn_sizeof_uint32_t(&val->height);
+    size += vn_sizeof_uint32_t(&val->layers);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferCreateInfo(const VkFramebufferCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkFramebufferCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkFramebufferCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkFramebufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkFramebufferCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkFramebufferAttachmentsCreateInfo_self(enc, (const VkFramebufferAttachmentsCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkFramebufferCreateInfo_self(struct vn_cs_encoder *enc, const VkFramebufferCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkRenderPass(enc, &val->renderPass);
+    vn_encode_uint32_t(enc, &val->attachmentCount);
+    if (val->pAttachments) {
+        vn_encode_array_size(enc, val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            vn_encode_VkImageView(enc, &val->pAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->width);
+    vn_encode_uint32_t(enc, &val->height);
+    vn_encode_uint32_t(enc, &val->layers);
+}
+
+static inline void
+vn_encode_VkFramebufferCreateInfo(struct vn_cs_encoder *enc, const VkFramebufferCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO });
+    vn_encode_VkFramebufferCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkFramebufferCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkFramebufferCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pFramebuffer);
+    if (pFramebuffer)
+        cmd_size += vn_sizeof_VkFramebuffer(pFramebuffer);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateFramebuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkFramebufferCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pFramebuffer))
+        vn_encode_VkFramebuffer(enc, pFramebuffer);
+}
+
+static inline size_t vn_sizeof_vkCreateFramebuffer_reply(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pFramebuffer);
+    if (pFramebuffer)
+        cmd_size += vn_sizeof_VkFramebuffer(pFramebuffer);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateFramebuffer_reply(struct vn_cs_decoder *dec, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateFramebuffer_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkFramebuffer(dec, pFramebuffer);
+    } else {
+        pFramebuffer = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkFramebuffer(&framebuffer);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyFramebuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkFramebuffer(enc, &framebuffer);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyFramebuffer_reply(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip framebuffer */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyFramebuffer_reply(struct vn_cs_decoder *dec, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT);
+
+    /* skip device */
+    /* skip framebuffer */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateFramebuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateFramebuffer(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pFramebuffer);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFramebuffer_reply(device, pCreateInfo, pAllocator, pFramebuffer) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyFramebuffer(device, framebuffer, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyFramebuffer(&submit->command, cmd_flags, device, framebuffer, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFramebuffer_reply(device, framebuffer, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateFramebuffer(struct vn_instance *vn_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateFramebuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pFramebuffer, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateFramebuffer_reply(&submit.reply, device, pCreateInfo, pAllocator, pFramebuffer);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateFramebuffer(struct vn_instance *vn_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateFramebuffer(vn_instance, 0, device, pCreateInfo, pAllocator, pFramebuffer, &submit);
+}
+
+static inline void vn_call_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyFramebuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, framebuffer, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyFramebuffer_reply(&submit.reply, device, framebuffer, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyFramebuffer(vn_instance, 0, device, framebuffer, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_FRAMEBUFFER_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_handles.h b/src/virtio/venus-protocol/vn_protocol_driver_handles.h
index 01c773f..9ce8aab 100644 (file)
--- a/src/virtio/venus-protocol/vn_protocol_driver_handles.h
+++ b/src/virtio/venus-protocol/vn_protocol_driver_handles.h
@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_image.h b/src/virtio/venus-protocol/vn_protocol_driver_image.h
new file mode 100644 (file)
index 0000000..67d0474
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_image.h
@@ -0,0 +1,2286 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_IMAGE_H
+#define VN_PROTOCOL_DRIVER_IMAGE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkSparseImageMemoryRequirements */
+
+static inline size_t
+vn_sizeof_VkSparseImageMemoryRequirements(const VkSparseImageMemoryRequirements *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkSparseImageFormatProperties(&val->formatProperties);
+    size += vn_sizeof_uint32_t(&val->imageMipTailFirstLod);
+    size += vn_sizeof_VkDeviceSize(&val->imageMipTailSize);
+    size += vn_sizeof_VkDeviceSize(&val->imageMipTailOffset);
+    size += vn_sizeof_VkDeviceSize(&val->imageMipTailStride);
+    return size;
+}
+
+static inline void
+vn_decode_VkSparseImageMemoryRequirements(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements *val)
+{
+    vn_decode_VkSparseImageFormatProperties(dec, &val->formatProperties);
+    vn_decode_uint32_t(dec, &val->imageMipTailFirstLod);
+    vn_decode_VkDeviceSize(dec, &val->imageMipTailSize);
+    vn_decode_VkDeviceSize(dec, &val->imageMipTailOffset);
+    vn_decode_VkDeviceSize(dec, &val->imageMipTailStride);
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageMemoryRequirements_partial(const VkSparseImageMemoryRequirements *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->formatProperties);
+    /* skip val->imageMipTailFirstLod */
+    /* skip val->imageMipTailSize */
+    /* skip val->imageMipTailOffset */
+    /* skip val->imageMipTailStride */
+    return size;
+}
+
+static inline void
+vn_encode_VkSparseImageMemoryRequirements_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements *val)
+{
+    vn_encode_VkSparseImageFormatProperties_partial(enc, &val->formatProperties);
+    /* skip val->imageMipTailFirstLod */
+    /* skip val->imageMipTailSize */
+    /* skip val->imageMipTailOffset */
+    /* skip val->imageMipTailStride */
+}
+
+/* struct VkExternalMemoryImageCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExternalMemoryImageCreateInfo_self(const VkExternalMemoryImageCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->handleTypes);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkExternalMemoryImageCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExternalMemoryImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExternalMemoryImageCreateInfo_self(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->handleTypes);
+}
+
+static inline void
+vn_encode_VkExternalMemoryImageCreateInfo(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO });
+    vn_encode_VkExternalMemoryImageCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkExternalMemoryImageCreateInfo_self(enc, val);
+}
+
+/* struct VkImageDrmFormatModifierListCreateInfoEXT chain */
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(const VkImageDrmFormatModifierListCreateInfoEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
+    if (val->pDrmFormatModifiers) {
+        size += vn_sizeof_array_size(val->drmFormatModifierCount);
+        size += vn_sizeof_uint64_t_array(val->pDrmFormatModifiers, val->drmFormatModifierCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(val->pNext);
+    size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->drmFormatModifierCount);
+    if (val->pDrmFormatModifiers) {
+        vn_encode_array_size(enc, val->drmFormatModifierCount);
+        vn_encode_uint64_t_array(enc, val->pDrmFormatModifiers, val->drmFormatModifierCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT });
+    vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(enc, val->pNext);
+    vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, val);
+}
+
+/* struct VkSubresourceLayout */
+
+static inline size_t
+vn_sizeof_VkSubresourceLayout(const VkSubresourceLayout *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkDeviceSize(&val->offset);
+    size += vn_sizeof_VkDeviceSize(&val->size);
+    size += vn_sizeof_VkDeviceSize(&val->rowPitch);
+    size += vn_sizeof_VkDeviceSize(&val->arrayPitch);
+    size += vn_sizeof_VkDeviceSize(&val->depthPitch);
+    return size;
+}
+
+static inline void
+vn_encode_VkSubresourceLayout(struct vn_cs_encoder *enc, const VkSubresourceLayout *val)
+{
+    vn_encode_VkDeviceSize(enc, &val->offset);
+    vn_encode_VkDeviceSize(enc, &val->size);
+    vn_encode_VkDeviceSize(enc, &val->rowPitch);
+    vn_encode_VkDeviceSize(enc, &val->arrayPitch);
+    vn_encode_VkDeviceSize(enc, &val->depthPitch);
+}
+
+static inline void
+vn_decode_VkSubresourceLayout(struct vn_cs_decoder *dec, VkSubresourceLayout *val)
+{
+    vn_decode_VkDeviceSize(dec, &val->offset);
+    vn_decode_VkDeviceSize(dec, &val->size);
+    vn_decode_VkDeviceSize(dec, &val->rowPitch);
+    vn_decode_VkDeviceSize(dec, &val->arrayPitch);
+    vn_decode_VkDeviceSize(dec, &val->depthPitch);
+}
+
+static inline size_t
+vn_sizeof_VkSubresourceLayout_partial(const VkSubresourceLayout *val)
+{
+    size_t size = 0;
+    /* skip val->offset */
+    /* skip val->size */
+    /* skip val->rowPitch */
+    /* skip val->arrayPitch */
+    /* skip val->depthPitch */
+    return size;
+}
+
+static inline void
+vn_encode_VkSubresourceLayout_partial(struct vn_cs_encoder *enc, const VkSubresourceLayout *val)
+{
+    /* skip val->offset */
+    /* skip val->size */
+    /* skip val->rowPitch */
+    /* skip val->arrayPitch */
+    /* skip val->depthPitch */
+}
+
+/* struct VkImageDrmFormatModifierExplicitCreateInfoEXT chain */
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint64_t(&val->drmFormatModifier);
+    size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
+    if (val->pPlaneLayouts) {
+        size += vn_sizeof_array_size(val->drmFormatModifierPlaneCount);
+        for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++)
+            size += vn_sizeof_VkSubresourceLayout(&val->pPlaneLayouts[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(val->pNext);
+    size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint64_t(enc, &val->drmFormatModifier);
+    vn_encode_uint32_t(enc, &val->drmFormatModifierPlaneCount);
+    if (val->pPlaneLayouts) {
+        vn_encode_array_size(enc, val->drmFormatModifierPlaneCount);
+        for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++)
+            vn_encode_VkSubresourceLayout(enc, &val->pPlaneLayouts[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT });
+    vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(enc, val->pNext);
+    vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, val);
+}
+
+/* struct VkImageCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkImageCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkExternalMemoryImageCreateInfo_self((const VkExternalMemoryImageCreateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self((const VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self((const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageCreateInfo_self(const VkImageCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkImageType(&val->imageType);
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkExtent3D(&val->extent);
+    size += vn_sizeof_uint32_t(&val->mipLevels);
+    size += vn_sizeof_uint32_t(&val->arrayLayers);
+    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
+    size += vn_sizeof_VkImageTiling(&val->tiling);
+    size += vn_sizeof_VkFlags(&val->usage);
+    size += vn_sizeof_VkSharingMode(&val->sharingMode);
+    size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
+    if (val->pQueueFamilyIndices) {
+        size += vn_sizeof_array_size(val->queueFamilyIndexCount);
+        size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_VkImageLayout(&val->initialLayout);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageCreateInfo(const VkImageCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkImageCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkExternalMemoryImageCreateInfo_self(enc, (const VkExternalMemoryImageCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkImageType(enc, &val->imageType);
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkExtent3D(enc, &val->extent);
+    vn_encode_uint32_t(enc, &val->mipLevels);
+    vn_encode_uint32_t(enc, &val->arrayLayers);
+    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
+    vn_encode_VkImageTiling(enc, &val->tiling);
+    vn_encode_VkFlags(enc, &val->usage);
+    vn_encode_VkSharingMode(enc, &val->sharingMode);
+    vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
+    if (val->pQueueFamilyIndices) {
+        vn_encode_array_size(enc, val->queueFamilyIndexCount);
+        vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkImageLayout(enc, &val->initialLayout);
+}
+
+static inline void
+vn_encode_VkImageCreateInfo(struct vn_cs_encoder *enc, const VkImageCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO });
+    vn_encode_VkImageCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkImageCreateInfo_self(enc, val);
+}
+
+/* struct VkBindImageMemoryDeviceGroupInfo chain */
+
+static inline size_t
+vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(const VkBindImageMemoryDeviceGroupInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->deviceIndexCount);
+    if (val->pDeviceIndices) {
+        size += vn_sizeof_array_size(val->deviceIndexCount);
+        size += vn_sizeof_uint32_t_array(val->pDeviceIndices, val->deviceIndexCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->splitInstanceBindRegionCount);
+    if (val->pSplitInstanceBindRegions) {
+        size += vn_sizeof_array_size(val->splitInstanceBindRegionCount);
+        for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
+            size += vn_sizeof_VkRect2D(&val->pSplitInstanceBindRegions[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->deviceIndexCount);
+    if (val->pDeviceIndices) {
+        vn_encode_array_size(enc, val->deviceIndexCount);
+        vn_encode_uint32_t_array(enc, val->pDeviceIndices, val->deviceIndexCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->splitInstanceBindRegionCount);
+    if (val->pSplitInstanceBindRegions) {
+        vn_encode_array_size(enc, val->splitInstanceBindRegionCount);
+        for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
+            vn_encode_VkRect2D(enc, &val->pSplitInstanceBindRegions[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO });
+    vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(enc, val->pNext);
+    vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->deviceIndexCount);
+    if (vn_peek_array_size(dec)) {
+        const size_t array_size = vn_decode_array_size(dec, val->deviceIndexCount);
+        vn_decode_uint32_t_array(dec, (uint32_t *)val->pDeviceIndices, array_size);
+    } else {
+        vn_decode_array_size(dec, 0);
+        val->pDeviceIndices = NULL;
+    }
+    vn_decode_uint32_t(dec, &val->splitInstanceBindRegionCount);
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, val->splitInstanceBindRegionCount);
+        for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
+            vn_decode_VkRect2D(dec, &((VkRect2D *)val->pSplitInstanceBindRegions)[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        val->pSplitInstanceBindRegions = NULL;
+    }
+}
+
+static inline void
+vn_decode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext(dec, val->pNext);
+    vn_decode_VkBindImageMemoryDeviceGroupInfo_self(dec, val);
+}
+
+/* struct VkBindImagePlaneMemoryInfo chain */
+
+static inline size_t
+vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBindImagePlaneMemoryInfo_self(const VkBindImagePlaneMemoryInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBindImagePlaneMemoryInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect);
+}
+
+static inline void
+vn_encode_VkBindImagePlaneMemoryInfo(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO });
+    vn_encode_VkBindImagePlaneMemoryInfo_pnext(enc, val->pNext);
+    vn_encode_VkBindImagePlaneMemoryInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkImageAspectFlagBits(dec, &val->planeAspect);
+}
+
+static inline void
+vn_decode_VkBindImagePlaneMemoryInfo(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkBindImagePlaneMemoryInfo_pnext(dec, val->pNext);
+    vn_decode_VkBindImagePlaneMemoryInfo_self(dec, val);
+}
+
+/* struct VkBindImageMemoryInfo chain */
+
+static inline size_t
+vn_sizeof_VkBindImageMemoryInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkBindImageMemoryInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self((const VkBindImageMemoryDeviceGroupInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkBindImageMemoryInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkBindImagePlaneMemoryInfo_self((const VkBindImagePlaneMemoryInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBindImageMemoryInfo_self(const VkBindImageMemoryInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkImage(&val->image);
+    size += vn_sizeof_VkDeviceMemory(&val->memory);
+    size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBindImageMemoryInfo(const VkBindImageMemoryInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBindImageMemoryInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBindImageMemoryInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBindImageMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, (const VkBindImageMemoryDeviceGroupInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkBindImagePlaneMemoryInfo_self(enc, (const VkBindImagePlaneMemoryInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBindImageMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkImage(enc, &val->image);
+    vn_encode_VkDeviceMemory(enc, &val->memory);
+    vn_encode_VkDeviceSize(enc, &val->memoryOffset);
+}
+
+static inline void
+vn_encode_VkBindImageMemoryInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO });
+    vn_encode_VkBindImageMemoryInfo_pnext(enc, val->pNext);
+    vn_encode_VkBindImageMemoryInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkBindImageMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return;
+
+    vn_decode_VkStructureType(dec, &stype);
+    while (true) {
+        assert(pnext);
+        if (pnext->sType == stype)
+            break;
+    }
+
+    switch ((int32_t)pnext->sType) {
+    case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+        vn_decode_VkBindImageMemoryInfo_pnext(dec, pnext->pNext);
+        vn_decode_VkBindImageMemoryDeviceGroupInfo_self(dec, (VkBindImageMemoryDeviceGroupInfo *)pnext);
+        break;
+    case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+        vn_decode_VkBindImageMemoryInfo_pnext(dec, pnext->pNext);
+        vn_decode_VkBindImagePlaneMemoryInfo_self(dec, (VkBindImagePlaneMemoryInfo *)pnext);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_decode_VkBindImageMemoryInfo_self(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkImage(dec, &val->image);
+    vn_decode_VkDeviceMemory(dec, &val->memory);
+    vn_decode_VkDeviceSize(dec, &val->memoryOffset);
+}
+
+static inline void
+vn_decode_VkBindImageMemoryInfo(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkBindImageMemoryInfo_pnext(dec, val->pNext);
+    vn_decode_VkBindImageMemoryInfo_self(dec, val);
+}
+
+/* struct VkImagePlaneMemoryRequirementsInfo chain */
+
+static inline size_t
+vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(const VkImagePlaneMemoryRequirementsInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(val->pNext);
+    size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImagePlaneMemoryRequirementsInfo_self(struct vn_cs_encoder *enc, const VkImagePlaneMemoryRequirementsInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect);
+}
+
+static inline void
+vn_encode_VkImagePlaneMemoryRequirementsInfo(struct vn_cs_encoder *enc, const VkImagePlaneMemoryRequirementsInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO });
+    vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(enc, val->pNext);
+    vn_encode_VkImagePlaneMemoryRequirementsInfo_self(enc, val);
+}
+
+/* struct VkImageMemoryRequirementsInfo2 chain */
+
+static inline size_t
+vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(pnext->pNext);
+            size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self((const VkImagePlaneMemoryRequirementsInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageMemoryRequirementsInfo2_self(const VkImageMemoryRequirementsInfo2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkImage(&val->image);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(val->pNext);
+    size += vn_sizeof_VkImageMemoryRequirementsInfo2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageMemoryRequirementsInfo2_pnext(enc, pnext->pNext);
+            vn_encode_VkImagePlaneMemoryRequirementsInfo_self(enc, (const VkImagePlaneMemoryRequirementsInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkImageMemoryRequirementsInfo2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkImage(enc, &val->image);
+}
+
+static inline void
+vn_encode_VkImageMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkImageMemoryRequirementsInfo2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 });
+    vn_encode_VkImageMemoryRequirementsInfo2_pnext(enc, val->pNext);
+    vn_encode_VkImageMemoryRequirementsInfo2_self(enc, val);
+}
+
+/* struct VkImageSparseMemoryRequirementsInfo2 chain */
+
+static inline size_t
+vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(const VkImageSparseMemoryRequirementsInfo2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkImage(&val->image);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(val->pNext);
+    size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageSparseMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkImageSparseMemoryRequirementsInfo2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkImage(enc, &val->image);
+}
+
+static inline void
+vn_encode_VkImageSparseMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkImageSparseMemoryRequirementsInfo2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 });
+    vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(enc, val->pNext);
+    vn_encode_VkImageSparseMemoryRequirementsInfo2_self(enc, val);
+}
+
+/* struct VkSparseImageMemoryRequirements2 chain */
+
+static inline size_t
+vn_sizeof_VkSparseImageMemoryRequirements2_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageMemoryRequirements2_self(const VkSparseImageMemoryRequirements2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkSparseImageMemoryRequirements(&val->memoryRequirements);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSparseImageMemoryRequirements2_pnext(val->pNext);
+    size += vn_sizeof_VkSparseImageMemoryRequirements2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkSparseImageMemoryRequirements2_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkSparseImageMemoryRequirements2_self(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkSparseImageMemoryRequirements(dec, &val->memoryRequirements);
+}
+
+static inline void
+vn_decode_VkSparseImageMemoryRequirements2(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2);
+
+    assert(val->sType == stype);
+    vn_decode_VkSparseImageMemoryRequirements2_pnext(dec, val->pNext);
+    vn_decode_VkSparseImageMemoryRequirements2_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(const VkSparseImageMemoryRequirements2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&val->memoryRequirements);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSparseImageMemoryRequirements2_partial(const VkSparseImageMemoryRequirements2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(val->pNext);
+    size += vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSparseImageMemoryRequirements2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkSparseImageMemoryRequirements_partial(enc, &val->memoryRequirements);
+}
+
+static inline void
+vn_encode_VkSparseImageMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 });
+    vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(enc, val->pNext);
+    vn_encode_VkSparseImageMemoryRequirements2_self_partial(enc, val);
+}
+
+/* struct VkImageDrmFormatModifierPropertiesEXT chain */
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(const VkImageDrmFormatModifierPropertiesEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint64_t(&val->drmFormatModifier);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(val->pNext);
+    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint64_t(dec, &val->drmFormatModifier);
+}
+
+static inline void
+vn_decode_VkImageDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT);
+
+    assert(val->sType == stype);
+    vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(dec, val->pNext);
+    vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(const VkImageDrmFormatModifierPropertiesEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->drmFormatModifier */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(const VkImageDrmFormatModifierPropertiesEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(val->pNext);
+    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->drmFormatModifier */
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT });
+    vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(enc, val->pNext);
+    vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(enc, val);
+}
+
+static inline size_t vn_sizeof_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkImage(&image);
+    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
+    if (pMemoryRequirements)
+        cmd_size += vn_sizeof_VkMemoryRequirements_partial(pMemoryRequirements);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkImage(enc, &image);
+    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
+        vn_encode_VkMemoryRequirements_partial(enc, pMemoryRequirements);
+}
+
+static inline size_t vn_sizeof_vkGetImageMemoryRequirements_reply(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip image */
+    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
+    if (pMemoryRequirements)
+        cmd_size += vn_sizeof_VkMemoryRequirements(pMemoryRequirements);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT);
+
+    /* skip device */
+    /* skip image */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkMemoryRequirements(dec, pMemoryRequirements);
+    } else {
+        pMemoryRequirements = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkImage(&image);
+    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
+    cmd_size += vn_sizeof_VkDeviceSize(&memoryOffset);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkBindImageMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkImage(enc, &image);
+    vn_encode_VkDeviceMemory(enc, &memory);
+    vn_encode_VkDeviceSize(enc, &memoryOffset);
+}
+
+static inline size_t vn_sizeof_vkBindImageMemory_reply(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip image */
+    /* skip memory */
+    /* skip memoryOffset */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkBindImageMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip image */
+    /* skip memory */
+    /* skip memoryOffset */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkImage(&image);
+    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
+    if (pSparseMemoryRequirementCount)
+        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
+    if (pSparseMemoryRequirements) {
+        cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount);
+        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
+            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&pSparseMemoryRequirements[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkImage(enc, &image);
+    if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
+        vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
+    if (pSparseMemoryRequirements) {
+        vn_encode_array_size(enc, *pSparseMemoryRequirementCount);
+        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
+            vn_encode_VkSparseImageMemoryRequirements_partial(enc, &pSparseMemoryRequirements[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements_reply(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip image */
+    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
+    if (pSparseMemoryRequirementCount)
+        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
+    if (pSparseMemoryRequirements) {
+        cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount);
+        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
+            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements(&pSparseMemoryRequirements[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT);
+
+    /* skip device */
+    /* skip image */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
+    } else {
+        pSparseMemoryRequirementCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pSparseMemoryRequirementCount);
+        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
+            vn_decode_VkSparseImageMemoryRequirements(dec, &pSparseMemoryRequirements[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pSparseMemoryRequirements = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkImageCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pImage);
+    if (pImage)
+        cmd_size += vn_sizeof_VkImage(pImage);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkImageCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pImage))
+        vn_encode_VkImage(enc, pImage);
+}
+
+static inline size_t vn_sizeof_vkCreateImage_reply(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pImage);
+    if (pImage)
+        cmd_size += vn_sizeof_VkImage(pImage);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateImage_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateImage_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkImage(dec, pImage);
+    } else {
+        pImage = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkImage(&image);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkImage(enc, &image);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyImage_reply(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip image */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyImage_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyImage_EXT);
+
+    /* skip device */
+    /* skip image */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkImage(&image);
+    cmd_size += vn_sizeof_simple_pointer(pSubresource);
+    if (pSubresource)
+        cmd_size += vn_sizeof_VkImageSubresource(pSubresource);
+    cmd_size += vn_sizeof_simple_pointer(pLayout);
+    if (pLayout)
+        cmd_size += vn_sizeof_VkSubresourceLayout_partial(pLayout);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetImageSubresourceLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkImage(enc, &image);
+    if (vn_encode_simple_pointer(enc, pSubresource))
+        vn_encode_VkImageSubresource(enc, pSubresource);
+    if (vn_encode_simple_pointer(enc, pLayout))
+        vn_encode_VkSubresourceLayout_partial(enc, pLayout);
+}
+
+static inline size_t vn_sizeof_vkGetImageSubresourceLayout_reply(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip image */
+    /* skip pSubresource */
+    cmd_size += vn_sizeof_simple_pointer(pLayout);
+    if (pLayout)
+        cmd_size += vn_sizeof_VkSubresourceLayout(pLayout);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetImageSubresourceLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT);
+
+    /* skip device */
+    /* skip image */
+    /* skip pSubresource */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkSubresourceLayout(dec, pLayout);
+    } else {
+        pLayout = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&bindInfoCount);
+    if (pBindInfos) {
+        cmd_size += vn_sizeof_array_size(bindInfoCount);
+        for (uint32_t i = 0; i < bindInfoCount; i++)
+            cmd_size += vn_sizeof_VkBindImageMemoryInfo(&pBindInfos[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkBindImageMemory2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &bindInfoCount);
+    if (pBindInfos) {
+        vn_encode_array_size(enc, bindInfoCount);
+        for (uint32_t i = 0; i < bindInfoCount; i++)
+            vn_encode_VkBindImageMemoryInfo(enc, &pBindInfos[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkBindImageMemory2_reply(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip bindInfoCount */
+    /* skip pBindInfos */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkBindImageMemory2_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory2_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip bindInfoCount */
+    /* skip pBindInfos */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pInfo);
+    if (pInfo)
+        cmd_size += vn_sizeof_VkImageMemoryRequirementsInfo2(pInfo);
+    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
+    if (pMemoryRequirements)
+        cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetImageMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pInfo))
+        vn_encode_VkImageMemoryRequirementsInfo2(enc, pInfo);
+    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
+        vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
+}
+
+static inline size_t vn_sizeof_vkGetImageMemoryRequirements2_reply(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pInfo */
+    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
+    if (pMemoryRequirements)
+        cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetImageMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT);
+
+    /* skip device */
+    /* skip pInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
+    } else {
+        pMemoryRequirements = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pInfo);
+    if (pInfo)
+        cmd_size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2(pInfo);
+    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
+    if (pSparseMemoryRequirementCount)
+        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
+    if (pSparseMemoryRequirements) {
+        cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount);
+        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
+            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetImageSparseMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pInfo))
+        vn_encode_VkImageSparseMemoryRequirementsInfo2(enc, pInfo);
+    if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
+        vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
+    if (pSparseMemoryRequirements) {
+        vn_encode_array_size(enc, *pSparseMemoryRequirementCount);
+        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
+            vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pInfo */
+    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
+    if (pSparseMemoryRequirementCount)
+        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
+    if (pSparseMemoryRequirements) {
+        cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount);
+        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
+            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT);
+
+    /* skip device */
+    /* skip pInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
+    } else {
+        pSparseMemoryRequirementCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pSparseMemoryRequirementCount);
+        for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++)
+            vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pSparseMemoryRequirements = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkImage(&image);
+    cmd_size += vn_sizeof_simple_pointer(pProperties);
+    if (pProperties)
+        cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(pProperties);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkImage(enc, &image);
+    if (vn_encode_simple_pointer(enc, pProperties))
+        vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(enc, pProperties);
+}
+
+static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip image */
+    cmd_size += vn_sizeof_simple_pointer(pProperties);
+    if (pProperties)
+        cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(pProperties);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip image */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkImageDrmFormatModifierPropertiesEXT(dec, pProperties);
+    } else {
+        pProperties = NULL;
+    }
+
+    return ret;
+}
+
+static inline void vn_submit_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetImageMemoryRequirements(&submit->command, cmd_flags, device, image, pMemoryRequirements);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements_reply(device, image, pMemoryRequirements) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkBindImageMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkBindImageMemory(device, image, memory, memoryOffset);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkBindImageMemory(&submit->command, cmd_flags, device, image, memory, memoryOffset);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory_reply(device, image, memory, memoryOffset) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetImageSparseMemoryRequirements(&submit->command, cmd_flags, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements_reply(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCreateImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateImage(device, pCreateInfo, pAllocator, pImage);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateImage(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pImage);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImage_reply(device, pCreateInfo, pAllocator, pImage) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyImage(device, image, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyImage(&submit->command, cmd_flags, device, image, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImage_reply(device, image, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetImageSubresourceLayout(&submit->command, cmd_flags, device, image, pSubresource, pLayout);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSubresourceLayout_reply(device, image, pSubresource, pLayout) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkBindImageMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkBindImageMemory2(device, bindInfoCount, pBindInfos);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkBindImageMemory2(&submit->command, cmd_flags, device, bindInfoCount, pBindInfos);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetImageMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pMemoryRequirements);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetImageSparseMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(&submit->command, cmd_flags, device, image, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(device, image, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_call_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pMemoryRequirements, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetImageMemoryRequirements_reply(&submit.reply, device, image, pMemoryRequirements);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageMemoryRequirements(vn_instance, 0, device, image, pMemoryRequirements, &submit);
+}
+
+static inline VkResult vn_call_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkBindImageMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, memory, memoryOffset, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkBindImageMemory_reply(&submit.reply, device, image, memory, memoryOffset);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkBindImageMemory(vn_instance, 0, device, image, memory, memoryOffset, &submit);
+}
+
+static inline void vn_call_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetImageSparseMemoryRequirements_reply(&submit.reply, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, 0, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
+}
+
+static inline VkResult vn_call_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pImage, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateImage_reply(&submit.reply, device, pCreateInfo, pAllocator, pImage);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateImage(vn_instance, 0, device, pCreateInfo, pAllocator, pImage, &submit);
+}
+
+static inline void vn_call_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyImage_reply(&submit.reply, device, image, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyImage(vn_instance, 0, device, image, pAllocator, &submit);
+}
+
+static inline void vn_call_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageSubresourceLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSubresource, pLayout, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetImageSubresourceLayout_reply(&submit.reply, device, image, pSubresource, pLayout);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageSubresourceLayout(vn_instance, 0, device, image, pSubresource, pLayout, &submit);
+}
+
+static inline VkResult vn_call_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkBindImageMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkBindImageMemory2_reply(&submit.reply, device, bindInfoCount, pBindInfos);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkBindImageMemory2(vn_instance, 0, device, bindInfoCount, pBindInfos, &submit);
+}
+
+static inline void vn_call_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetImageMemoryRequirements2_reply(&submit.reply, device, pInfo, pMemoryRequirements);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
+}
+
+static inline void vn_call_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetImageSparseMemoryRequirements2_reply(&submit.reply, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
+}
+
+static inline VkResult vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pProperties, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(&submit.reply, device, image, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, 0, device, image, pProperties, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_IMAGE_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_image_view.h b/src/virtio/venus-protocol/vn_protocol_driver_image_view.h
new file mode 100644 (file)
index 0000000..f842f1d
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_image_view.h
@@ -0,0 +1,376 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_IMAGE_VIEW_H
+#define VN_PROTOCOL_DRIVER_IMAGE_VIEW_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkImageViewUsageCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkImageViewUsageCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageViewUsageCreateInfo_self(const VkImageViewUsageCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->usage);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageViewUsageCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkImageViewUsageCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageViewUsageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageViewUsageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageViewUsageCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->usage);
+}
+
+static inline void
+vn_encode_VkImageViewUsageCreateInfo(struct vn_cs_encoder *enc, const VkImageViewUsageCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO });
+    vn_encode_VkImageViewUsageCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkImageViewUsageCreateInfo_self(enc, val);
+}
+
+/* struct VkImageViewCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkImageViewCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageViewCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkImageViewUsageCreateInfo_self((const VkImageViewUsageCreateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageViewCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkSamplerYcbcrConversionInfo_self((const VkSamplerYcbcrConversionInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageViewCreateInfo_self(const VkImageViewCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkImage(&val->image);
+    size += vn_sizeof_VkImageViewType(&val->viewType);
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkComponentMapping(&val->components);
+    size += vn_sizeof_VkImageSubresourceRange(&val->subresourceRange);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageViewCreateInfo(const VkImageViewCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageViewCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkImageViewCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageViewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageViewCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkImageViewUsageCreateInfo_self(enc, (const VkImageViewUsageCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageViewCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkSamplerYcbcrConversionInfo_self(enc, (const VkSamplerYcbcrConversionInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageViewCreateInfo_self(struct vn_cs_encoder *enc, const VkImageViewCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkImage(enc, &val->image);
+    vn_encode_VkImageViewType(enc, &val->viewType);
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkComponentMapping(enc, &val->components);
+    vn_encode_VkImageSubresourceRange(enc, &val->subresourceRange);
+}
+
+static inline void
+vn_encode_VkImageViewCreateInfo(struct vn_cs_encoder *enc, const VkImageViewCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO });
+    vn_encode_VkImageViewCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkImageViewCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkImageViewCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pView);
+    if (pView)
+        cmd_size += vn_sizeof_VkImageView(pView);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateImageView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkImageViewCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pView))
+        vn_encode_VkImageView(enc, pView);
+}
+
+static inline size_t vn_sizeof_vkCreateImageView_reply(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pView);
+    if (pView)
+        cmd_size += vn_sizeof_VkImageView(pView);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateImageView_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateImageView_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkImageView(dec, pView);
+    } else {
+        pView = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkImageView(&imageView);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyImageView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkImageView(enc, &imageView);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyImageView_reply(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip imageView */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyImageView_reply(struct vn_cs_decoder *dec, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyImageView_EXT);
+
+    /* skip device */
+    /* skip imageView */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateImageView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateImageView(device, pCreateInfo, pAllocator, pView);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateImageView(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pView);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImageView_reply(device, pCreateInfo, pAllocator, pView) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyImageView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyImageView(device, imageView, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyImageView(&submit->command, cmd_flags, device, imageView, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImageView_reply(device, imageView, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateImageView(struct vn_instance *vn_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateImageView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateImageView_reply(&submit.reply, device, pCreateInfo, pAllocator, pView);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateImageView(struct vn_instance *vn_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateImageView(vn_instance, 0, device, pCreateInfo, pAllocator, pView, &submit);
+}
+
+static inline void vn_call_vkDestroyImageView(struct vn_instance *vn_instance, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyImageView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, imageView, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyImageView_reply(&submit.reply, device, imageView, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyImageView(struct vn_instance *vn_instance, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyImageView(vn_instance, 0, device, imageView, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_IMAGE_VIEW_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_info.h b/src/virtio/venus-protocol/vn_protocol_driver_info.h
index f12d177..e2d7350 100644 (file)
--- a/src/virtio/venus-protocol/vn_protocol_driver_info.h
+++ b/src/virtio/venus-protocol/vn_protocol_driver_info.h
@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_instance.h b/src/virtio/venus-protocol/vn_protocol_driver_instance.h
new file mode 100644 (file)
index 0000000..7aa9a66
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_instance.h
@@ -0,0 +1,756 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_INSTANCE_H
+#define VN_PROTOCOL_DRIVER_INSTANCE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/*
+ * These structs/unions/commands are not included
+ *
+ *   vkGetInstanceProcAddr
+ */
+
+/* struct VkApplicationInfo chain */
+
+static inline size_t
+vn_sizeof_VkApplicationInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkApplicationInfo_self(const VkApplicationInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    if (val->pApplicationName) {
+        const size_t string_size = strlen(val->pApplicationName) + 1;
+        size += vn_sizeof_array_size(string_size);
+        size += vn_sizeof_blob_array(val->pApplicationName, string_size);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->applicationVersion);
+    if (val->pEngineName) {
+        const size_t string_size = strlen(val->pEngineName) + 1;
+        size += vn_sizeof_array_size(string_size);
+        size += vn_sizeof_blob_array(val->pEngineName, string_size);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->engineVersion);
+    size += vn_sizeof_uint32_t(&val->apiVersion);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkApplicationInfo(const VkApplicationInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkApplicationInfo_pnext(val->pNext);
+    size += vn_sizeof_VkApplicationInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkApplicationInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkApplicationInfo_self(struct vn_cs_encoder *enc, const VkApplicationInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    if (val->pApplicationName) {
+        const size_t string_size = strlen(val->pApplicationName) + 1;
+        vn_encode_array_size(enc, string_size);
+        vn_encode_blob_array(enc, val->pApplicationName, string_size);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->applicationVersion);
+    if (val->pEngineName) {
+        const size_t string_size = strlen(val->pEngineName) + 1;
+        vn_encode_array_size(enc, string_size);
+        vn_encode_blob_array(enc, val->pEngineName, string_size);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->engineVersion);
+    vn_encode_uint32_t(enc, &val->apiVersion);
+}
+
+static inline void
+vn_encode_VkApplicationInfo(struct vn_cs_encoder *enc, const VkApplicationInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_APPLICATION_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_APPLICATION_INFO });
+    vn_encode_VkApplicationInfo_pnext(enc, val->pNext);
+    vn_encode_VkApplicationInfo_self(enc, val);
+}
+
+/* struct VkInstanceCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkInstanceCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkInstanceCreateInfo_self(const VkInstanceCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_simple_pointer(val->pApplicationInfo);
+    if (val->pApplicationInfo)
+        size += vn_sizeof_VkApplicationInfo(val->pApplicationInfo);
+    size += vn_sizeof_uint32_t(&val->enabledLayerCount);
+    if (val->ppEnabledLayerNames) {
+        size += vn_sizeof_array_size(val->enabledLayerCount);
+        for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
+            size += vn_sizeof_array_size(string_size);
+            size += vn_sizeof_blob_array(val->ppEnabledLayerNames[i], string_size);
+        }
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->enabledExtensionCount);
+    if (val->ppEnabledExtensionNames) {
+        size += vn_sizeof_array_size(val->enabledExtensionCount);
+        for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
+            size += vn_sizeof_array_size(string_size);
+            size += vn_sizeof_blob_array(val->ppEnabledExtensionNames[i], string_size);
+        }
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkInstanceCreateInfo(const VkInstanceCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkInstanceCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkInstanceCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkInstanceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkInstanceCreateInfo_self(struct vn_cs_encoder *enc, const VkInstanceCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    if (vn_encode_simple_pointer(enc, val->pApplicationInfo))
+        vn_encode_VkApplicationInfo(enc, val->pApplicationInfo);
+    vn_encode_uint32_t(enc, &val->enabledLayerCount);
+    if (val->ppEnabledLayerNames) {
+        vn_encode_array_size(enc, val->enabledLayerCount);
+        for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
+            vn_encode_array_size(enc, string_size);
+            vn_encode_blob_array(enc, val->ppEnabledLayerNames[i], string_size);
+        }
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->enabledExtensionCount);
+    if (val->ppEnabledExtensionNames) {
+        vn_encode_array_size(enc, val->enabledExtensionCount);
+        for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
+            vn_encode_array_size(enc, string_size);
+            vn_encode_blob_array(enc, val->ppEnabledExtensionNames[i], string_size);
+        }
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkInstanceCreateInfo(struct vn_cs_encoder *enc, const VkInstanceCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO });
+    vn_encode_VkInstanceCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkInstanceCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkInstanceCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pInstance);
+    if (pInstance)
+        cmd_size += vn_sizeof_VkInstance(pInstance);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateInstance(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkInstanceCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pInstance))
+        vn_encode_VkInstance(enc, pInstance);
+}
+
+static inline size_t vn_sizeof_vkCreateInstance_reply(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pInstance);
+    if (pInstance)
+        cmd_size += vn_sizeof_VkInstance(pInstance);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateInstance_reply(struct vn_cs_decoder *dec, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateInstance_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkInstance(dec, pInstance);
+    } else {
+        pInstance = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkInstance(&instance);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyInstance(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkInstance(enc, &instance);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyInstance_reply(VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip instance */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyInstance_reply(struct vn_cs_decoder *dec, VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyInstance_EXT);
+
+    /* skip instance */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceVersion(uint32_t* pApiVersion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_simple_pointer(pApiVersion); /* out */
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEnumerateInstanceVersion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t* pApiVersion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_simple_pointer(enc, pApiVersion); /* out */
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceVersion_reply(uint32_t* pApiVersion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    cmd_size += vn_sizeof_simple_pointer(pApiVersion);
+    if (pApiVersion)
+        cmd_size += vn_sizeof_uint32_t(pApiVersion);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEnumerateInstanceVersion_reply(struct vn_cs_decoder *dec, uint32_t* pApiVersion)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pApiVersion);
+    } else {
+        pApiVersion = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEnumerateInstanceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    if (vn_encode_simple_pointer(enc, pPropertyCount))
+        vn_encode_uint32_t(enc, pPropertyCount);
+    if (pProperties) {
+        vn_encode_array_size(enc, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_encode_VkLayerProperties_partial(enc, &pProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceLayerProperties_reply(uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEnumerateInstanceLayerProperties_reply(struct vn_cs_decoder *dec, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pPropertyCount);
+    } else {
+        pPropertyCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_decode_VkLayerProperties(dec, &pProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pProperties = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    if (pLayerName) {
+        const size_t string_size = strlen(pLayerName) + 1;
+        cmd_size += vn_sizeof_array_size(string_size);
+        cmd_size += vn_sizeof_blob_array(pLayerName, string_size);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEnumerateInstanceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    if (pLayerName) {
+        const size_t string_size = strlen(pLayerName) + 1;
+        vn_encode_array_size(enc, string_size);
+        vn_encode_blob_array(enc, pLayerName, string_size);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (vn_encode_simple_pointer(enc, pPropertyCount))
+        vn_encode_uint32_t(enc, pPropertyCount);
+    if (pProperties) {
+        vn_encode_array_size(enc, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceExtensionProperties_reply(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip pLayerName */
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEnumerateInstanceExtensionProperties_reply(struct vn_cs_decoder *dec, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip pLayerName */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pPropertyCount);
+    } else {
+        pPropertyCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_decode_VkExtensionProperties(dec, &pProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pProperties = NULL;
+    }
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateInstance(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateInstance(pCreateInfo, pAllocator, pInstance);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateInstance(&submit->command, cmd_flags, pCreateInfo, pAllocator, pInstance);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateInstance_reply(pCreateInfo, pAllocator, pInstance) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyInstance(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyInstance(instance, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyInstance(&submit->command, cmd_flags, instance, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyInstance_reply(instance, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t* pApiVersion, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEnumerateInstanceVersion(pApiVersion);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEnumerateInstanceVersion(&submit->command, cmd_flags, pApiVersion);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceVersion_reply(pApiVersion) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEnumerateInstanceLayerProperties(&submit->command, cmd_flags, pPropertyCount, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceLayerProperties_reply(pPropertyCount, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEnumerateInstanceExtensionProperties(&submit->command, cmd_flags, pLayerName, pPropertyCount, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceExtensionProperties_reply(pLayerName, pPropertyCount, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateInstance(struct vn_instance *vn_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateInstance(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pCreateInfo, pAllocator, pInstance, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateInstance_reply(&submit.reply, pCreateInfo, pAllocator, pInstance);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateInstance(struct vn_instance *vn_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateInstance(vn_instance, 0, pCreateInfo, pAllocator, pInstance, &submit);
+}
+
+static inline void vn_call_vkDestroyInstance(struct vn_instance *vn_instance, VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyInstance(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyInstance_reply(&submit.reply, instance, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyInstance(struct vn_instance *vn_instance, VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyInstance(vn_instance, 0, instance, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, uint32_t* pApiVersion)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceVersion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pApiVersion, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEnumerateInstanceVersion_reply(&submit.reply, pApiVersion);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, uint32_t* pApiVersion)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceVersion(vn_instance, 0, pApiVersion, &submit);
+}
+
+static inline VkResult vn_call_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pPropertyCount, pProperties, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEnumerateInstanceLayerProperties_reply(&submit.reply, pPropertyCount, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceLayerProperties(vn_instance, 0, pPropertyCount, pProperties, &submit);
+}
+
+static inline VkResult vn_call_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pLayerName, pPropertyCount, pProperties, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEnumerateInstanceExtensionProperties_reply(&submit.reply, pLayerName, pPropertyCount, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceExtensionProperties(vn_instance, 0, pLayerName, pPropertyCount, pProperties, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_INSTANCE_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_pipeline.h b/src/virtio/venus-protocol/vn_protocol_driver_pipeline.h
new file mode 100644 (file)
index 0000000..d741ff5
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_pipeline.h
@@ -0,0 +1,1638 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_PIPELINE_H
+#define VN_PROTOCOL_DRIVER_PIPELINE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkSpecializationMapEntry */
+
+static inline size_t
+vn_sizeof_VkSpecializationMapEntry(const VkSpecializationMapEntry *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->constantID);
+    size += vn_sizeof_uint32_t(&val->offset);
+    size += vn_sizeof_size_t(&val->size);
+    return size;
+}
+
+static inline void
+vn_encode_VkSpecializationMapEntry(struct vn_cs_encoder *enc, const VkSpecializationMapEntry *val)
+{
+    vn_encode_uint32_t(enc, &val->constantID);
+    vn_encode_uint32_t(enc, &val->offset);
+    vn_encode_size_t(enc, &val->size);
+}
+
+/* struct VkSpecializationInfo */
+
+static inline size_t
+vn_sizeof_VkSpecializationInfo(const VkSpecializationInfo *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->mapEntryCount);
+    if (val->pMapEntries) {
+        size += vn_sizeof_array_size(val->mapEntryCount);
+        for (uint32_t i = 0; i < val->mapEntryCount; i++)
+            size += vn_sizeof_VkSpecializationMapEntry(&val->pMapEntries[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_size_t(&val->dataSize);
+    if (val->pData) {
+        size += vn_sizeof_array_size(val->dataSize);
+        size += vn_sizeof_blob_array(val->pData, val->dataSize);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline void
+vn_encode_VkSpecializationInfo(struct vn_cs_encoder *enc, const VkSpecializationInfo *val)
+{
+    vn_encode_uint32_t(enc, &val->mapEntryCount);
+    if (val->pMapEntries) {
+        vn_encode_array_size(enc, val->mapEntryCount);
+        for (uint32_t i = 0; i < val->mapEntryCount; i++)
+            vn_encode_VkSpecializationMapEntry(enc, &val->pMapEntries[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_size_t(enc, &val->dataSize);
+    if (val->pData) {
+        vn_encode_array_size(enc, val->dataSize);
+        vn_encode_blob_array(enc, val->pData, val->dataSize);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+/* struct VkPipelineShaderStageCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineShaderStageCreateInfo_self(const VkPipelineShaderStageCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkShaderStageFlagBits(&val->stage);
+    size += vn_sizeof_VkShaderModule(&val->module);
+    if (val->pName) {
+        const size_t string_size = strlen(val->pName) + 1;
+        size += vn_sizeof_array_size(string_size);
+        size += vn_sizeof_blob_array(val->pName, string_size);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_simple_pointer(val->pSpecializationInfo);
+    if (val->pSpecializationInfo)
+        size += vn_sizeof_VkSpecializationInfo(val->pSpecializationInfo);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineShaderStageCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineShaderStageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineShaderStageCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkShaderStageFlagBits(enc, &val->stage);
+    vn_encode_VkShaderModule(enc, &val->module);
+    if (val->pName) {
+        const size_t string_size = strlen(val->pName) + 1;
+        vn_encode_array_size(enc, string_size);
+        vn_encode_blob_array(enc, val->pName, string_size);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (vn_encode_simple_pointer(enc, val->pSpecializationInfo))
+        vn_encode_VkSpecializationInfo(enc, val->pSpecializationInfo);
+}
+
+static inline void
+vn_encode_VkPipelineShaderStageCreateInfo(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO });
+    vn_encode_VkPipelineShaderStageCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineShaderStageCreateInfo_self(enc, val);
+}
+
+/* struct VkVertexInputBindingDescription */
+
+static inline size_t
+vn_sizeof_VkVertexInputBindingDescription(const VkVertexInputBindingDescription *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->binding);
+    size += vn_sizeof_uint32_t(&val->stride);
+    size += vn_sizeof_VkVertexInputRate(&val->inputRate);
+    return size;
+}
+
+static inline void
+vn_encode_VkVertexInputBindingDescription(struct vn_cs_encoder *enc, const VkVertexInputBindingDescription *val)
+{
+    vn_encode_uint32_t(enc, &val->binding);
+    vn_encode_uint32_t(enc, &val->stride);
+    vn_encode_VkVertexInputRate(enc, &val->inputRate);
+}
+
+/* struct VkVertexInputAttributeDescription */
+
+static inline size_t
+vn_sizeof_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->location);
+    size += vn_sizeof_uint32_t(&val->binding);
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_uint32_t(&val->offset);
+    return size;
+}
+
+static inline void
+vn_encode_VkVertexInputAttributeDescription(struct vn_cs_encoder *enc, const VkVertexInputAttributeDescription *val)
+{
+    vn_encode_uint32_t(enc, &val->location);
+    vn_encode_uint32_t(enc, &val->binding);
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_uint32_t(enc, &val->offset);
+}
+
+/* struct VkPipelineVertexInputStateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(const VkPipelineVertexInputStateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->vertexBindingDescriptionCount);
+    if (val->pVertexBindingDescriptions) {
+        size += vn_sizeof_array_size(val->vertexBindingDescriptionCount);
+        for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++)
+            size += vn_sizeof_VkVertexInputBindingDescription(&val->pVertexBindingDescriptions[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->vertexAttributeDescriptionCount);
+    if (val->pVertexAttributeDescriptions) {
+        size += vn_sizeof_array_size(val->vertexAttributeDescriptionCount);
+        for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++)
+            size += vn_sizeof_VkVertexInputAttributeDescription(&val->pVertexAttributeDescriptions[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineVertexInputStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineVertexInputStateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->vertexBindingDescriptionCount);
+    if (val->pVertexBindingDescriptions) {
+        vn_encode_array_size(enc, val->vertexBindingDescriptionCount);
+        for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++)
+            vn_encode_VkVertexInputBindingDescription(enc, &val->pVertexBindingDescriptions[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->vertexAttributeDescriptionCount);
+    if (val->pVertexAttributeDescriptions) {
+        vn_encode_array_size(enc, val->vertexAttributeDescriptionCount);
+        for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++)
+            vn_encode_VkVertexInputAttributeDescription(enc, &val->pVertexAttributeDescriptions[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkPipelineVertexInputStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineVertexInputStateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO });
+    vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineVertexInputStateCreateInfo_self(enc, val);
+}
+
+/* struct VkPipelineInputAssemblyStateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(const VkPipelineInputAssemblyStateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkPrimitiveTopology(&val->topology);
+    size += vn_sizeof_VkBool32(&val->primitiveRestartEnable);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineInputAssemblyStateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkPrimitiveTopology(enc, &val->topology);
+    vn_encode_VkBool32(enc, &val->primitiveRestartEnable);
+}
+
+static inline void
+vn_encode_VkPipelineInputAssemblyStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineInputAssemblyStateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO });
+    vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(enc, val);
+}
+
+/* struct VkPipelineTessellationDomainOriginStateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(const VkPipelineTessellationDomainOriginStateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkTessellationDomainOrigin(&val->domainOrigin);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineTessellationDomainOriginStateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkTessellationDomainOrigin(enc, &val->domainOrigin);
+}
+
+static inline void
+vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineTessellationDomainOriginStateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO });
+    vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(enc, val);
+}
+
+/* struct VkPipelineTessellationStateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self((const VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineTessellationStateCreateInfo_self(const VkPipelineTessellationStateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->patchControlPoints);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineTessellationStateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineTessellationStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPipelineTessellationStateCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(enc, (const VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineTessellationStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineTessellationStateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->patchControlPoints);
+}
+
+static inline void
+vn_encode_VkPipelineTessellationStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineTessellationStateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO });
+    vn_encode_VkPipelineTessellationStateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineTessellationStateCreateInfo_self(enc, val);
+}
+
+/* struct VkPipelineViewportStateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineViewportStateCreateInfo_self(const VkPipelineViewportStateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->viewportCount);
+    if (val->pViewports) {
+        size += vn_sizeof_array_size(val->viewportCount);
+        for (uint32_t i = 0; i < val->viewportCount; i++)
+            size += vn_sizeof_VkViewport(&val->pViewports[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->scissorCount);
+    if (val->pScissors) {
+        size += vn_sizeof_array_size(val->scissorCount);
+        for (uint32_t i = 0; i < val->scissorCount; i++)
+            size += vn_sizeof_VkRect2D(&val->pScissors[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineViewportStateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineViewportStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineViewportStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineViewportStateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->viewportCount);
+    if (val->pViewports) {
+        vn_encode_array_size(enc, val->viewportCount);
+        for (uint32_t i = 0; i < val->viewportCount; i++)
+            vn_encode_VkViewport(enc, &val->pViewports[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->scissorCount);
+    if (val->pScissors) {
+        vn_encode_array_size(enc, val->scissorCount);
+        for (uint32_t i = 0; i < val->scissorCount; i++)
+            vn_encode_VkRect2D(enc, &val->pScissors[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkPipelineViewportStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineViewportStateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO });
+    vn_encode_VkPipelineViewportStateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineViewportStateCreateInfo_self(enc, val);
+}
+
+/* struct VkPipelineRasterizationStateStreamCreateInfoEXT chain */
+
+static inline size_t
+vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->rasterizationStream);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->rasterizationStream);
+}
+
+static inline void
+vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT });
+    vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(enc, val->pNext);
+    vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(enc, val);
+}
+
+/* struct VkPipelineRasterizationStateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self((const VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(const VkPipelineRasterizationStateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkBool32(&val->depthClampEnable);
+    size += vn_sizeof_VkBool32(&val->rasterizerDiscardEnable);
+    size += vn_sizeof_VkPolygonMode(&val->polygonMode);
+    size += vn_sizeof_VkFlags(&val->cullMode);
+    size += vn_sizeof_VkFrontFace(&val->frontFace);
+    size += vn_sizeof_VkBool32(&val->depthBiasEnable);
+    size += vn_sizeof_float(&val->depthBiasConstantFactor);
+    size += vn_sizeof_float(&val->depthBiasClamp);
+    size += vn_sizeof_float(&val->depthBiasSlopeFactor);
+    size += vn_sizeof_float(&val->lineWidth);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(enc, (const VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineRasterizationStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkBool32(enc, &val->depthClampEnable);
+    vn_encode_VkBool32(enc, &val->rasterizerDiscardEnable);
+    vn_encode_VkPolygonMode(enc, &val->polygonMode);
+    vn_encode_VkFlags(enc, &val->cullMode);
+    vn_encode_VkFrontFace(enc, &val->frontFace);
+    vn_encode_VkBool32(enc, &val->depthBiasEnable);
+    vn_encode_float(enc, &val->depthBiasConstantFactor);
+    vn_encode_float(enc, &val->depthBiasClamp);
+    vn_encode_float(enc, &val->depthBiasSlopeFactor);
+    vn_encode_float(enc, &val->lineWidth);
+}
+
+static inline void
+vn_encode_VkPipelineRasterizationStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO });
+    vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineRasterizationStateCreateInfo_self(enc, val);
+}
+
+/* struct VkPipelineMultisampleStateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(const VkPipelineMultisampleStateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkSampleCountFlagBits(&val->rasterizationSamples);
+    size += vn_sizeof_VkBool32(&val->sampleShadingEnable);
+    size += vn_sizeof_float(&val->minSampleShading);
+    if (val->pSampleMask) {
+        size += vn_sizeof_array_size((val->rasterizationSamples + 31) / 32);
+        size += vn_sizeof_VkSampleMask_array(val->pSampleMask, (val->rasterizationSamples + 31) / 32);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_VkBool32(&val->alphaToCoverageEnable);
+    size += vn_sizeof_VkBool32(&val->alphaToOneEnable);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineMultisampleStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineMultisampleStateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkSampleCountFlagBits(enc, &val->rasterizationSamples);
+    vn_encode_VkBool32(enc, &val->sampleShadingEnable);
+    vn_encode_float(enc, &val->minSampleShading);
+    if (val->pSampleMask) {
+        vn_encode_array_size(enc, (val->rasterizationSamples + 31) / 32);
+        vn_encode_VkSampleMask_array(enc, val->pSampleMask, (val->rasterizationSamples + 31) / 32);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkBool32(enc, &val->alphaToCoverageEnable);
+    vn_encode_VkBool32(enc, &val->alphaToOneEnable);
+}
+
+static inline void
+vn_encode_VkPipelineMultisampleStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineMultisampleStateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO });
+    vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineMultisampleStateCreateInfo_self(enc, val);
+}
+
+/* struct VkStencilOpState */
+
+static inline size_t
+vn_sizeof_VkStencilOpState(const VkStencilOpState *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkStencilOp(&val->failOp);
+    size += vn_sizeof_VkStencilOp(&val->passOp);
+    size += vn_sizeof_VkStencilOp(&val->depthFailOp);
+    size += vn_sizeof_VkCompareOp(&val->compareOp);
+    size += vn_sizeof_uint32_t(&val->compareMask);
+    size += vn_sizeof_uint32_t(&val->writeMask);
+    size += vn_sizeof_uint32_t(&val->reference);
+    return size;
+}
+
+static inline void
+vn_encode_VkStencilOpState(struct vn_cs_encoder *enc, const VkStencilOpState *val)
+{
+    vn_encode_VkStencilOp(enc, &val->failOp);
+    vn_encode_VkStencilOp(enc, &val->passOp);
+    vn_encode_VkStencilOp(enc, &val->depthFailOp);
+    vn_encode_VkCompareOp(enc, &val->compareOp);
+    vn_encode_uint32_t(enc, &val->compareMask);
+    vn_encode_uint32_t(enc, &val->writeMask);
+    vn_encode_uint32_t(enc, &val->reference);
+}
+
+/* struct VkPipelineDepthStencilStateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(const VkPipelineDepthStencilStateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkBool32(&val->depthTestEnable);
+    size += vn_sizeof_VkBool32(&val->depthWriteEnable);
+    size += vn_sizeof_VkCompareOp(&val->depthCompareOp);
+    size += vn_sizeof_VkBool32(&val->depthBoundsTestEnable);
+    size += vn_sizeof_VkBool32(&val->stencilTestEnable);
+    size += vn_sizeof_VkStencilOpState(&val->front);
+    size += vn_sizeof_VkStencilOpState(&val->back);
+    size += vn_sizeof_float(&val->minDepthBounds);
+    size += vn_sizeof_float(&val->maxDepthBounds);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineDepthStencilStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkBool32(enc, &val->depthTestEnable);
+    vn_encode_VkBool32(enc, &val->depthWriteEnable);
+    vn_encode_VkCompareOp(enc, &val->depthCompareOp);
+    vn_encode_VkBool32(enc, &val->depthBoundsTestEnable);
+    vn_encode_VkBool32(enc, &val->stencilTestEnable);
+    vn_encode_VkStencilOpState(enc, &val->front);
+    vn_encode_VkStencilOpState(enc, &val->back);
+    vn_encode_float(enc, &val->minDepthBounds);
+    vn_encode_float(enc, &val->maxDepthBounds);
+}
+
+static inline void
+vn_encode_VkPipelineDepthStencilStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO });
+    vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineDepthStencilStateCreateInfo_self(enc, val);
+}
+
+/* struct VkPipelineColorBlendAttachmentState */
+
+static inline size_t
+vn_sizeof_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkBool32(&val->blendEnable);
+    size += vn_sizeof_VkBlendFactor(&val->srcColorBlendFactor);
+    size += vn_sizeof_VkBlendFactor(&val->dstColorBlendFactor);
+    size += vn_sizeof_VkBlendOp(&val->colorBlendOp);
+    size += vn_sizeof_VkBlendFactor(&val->srcAlphaBlendFactor);
+    size += vn_sizeof_VkBlendFactor(&val->dstAlphaBlendFactor);
+    size += vn_sizeof_VkBlendOp(&val->alphaBlendOp);
+    size += vn_sizeof_VkFlags(&val->colorWriteMask);
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineColorBlendAttachmentState(struct vn_cs_encoder *enc, const VkPipelineColorBlendAttachmentState *val)
+{
+    vn_encode_VkBool32(enc, &val->blendEnable);
+    vn_encode_VkBlendFactor(enc, &val->srcColorBlendFactor);
+    vn_encode_VkBlendFactor(enc, &val->dstColorBlendFactor);
+    vn_encode_VkBlendOp(enc, &val->colorBlendOp);
+    vn_encode_VkBlendFactor(enc, &val->srcAlphaBlendFactor);
+    vn_encode_VkBlendFactor(enc, &val->dstAlphaBlendFactor);
+    vn_encode_VkBlendOp(enc, &val->alphaBlendOp);
+    vn_encode_VkFlags(enc, &val->colorWriteMask);
+}
+
+/* struct VkPipelineColorBlendStateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(const VkPipelineColorBlendStateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkBool32(&val->logicOpEnable);
+    size += vn_sizeof_VkLogicOp(&val->logicOp);
+    size += vn_sizeof_uint32_t(&val->attachmentCount);
+    if (val->pAttachments) {
+        size += vn_sizeof_array_size(val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            size += vn_sizeof_VkPipelineColorBlendAttachmentState(&val->pAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_array_size(4);
+    size += vn_sizeof_float_array(val->blendConstants, 4);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineColorBlendStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkBool32(enc, &val->logicOpEnable);
+    vn_encode_VkLogicOp(enc, &val->logicOp);
+    vn_encode_uint32_t(enc, &val->attachmentCount);
+    if (val->pAttachments) {
+        vn_encode_array_size(enc, val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            vn_encode_VkPipelineColorBlendAttachmentState(enc, &val->pAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_array_size(enc, 4);
+    vn_encode_float_array(enc, val->blendConstants, 4);
+}
+
+static inline void
+vn_encode_VkPipelineColorBlendStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO });
+    vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineColorBlendStateCreateInfo_self(enc, val);
+}
+
+/* struct VkPipelineDynamicStateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineDynamicStateCreateInfo_self(const VkPipelineDynamicStateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->dynamicStateCount);
+    if (val->pDynamicStates) {
+        size += vn_sizeof_array_size(val->dynamicStateCount);
+        size += vn_sizeof_VkDynamicState_array(val->pDynamicStates, val->dynamicStateCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineDynamicStateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineDynamicStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineDynamicStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineDynamicStateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->dynamicStateCount);
+    if (val->pDynamicStates) {
+        vn_encode_array_size(enc, val->dynamicStateCount);
+        vn_encode_VkDynamicState_array(enc, val->pDynamicStates, val->dynamicStateCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkPipelineDynamicStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineDynamicStateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO });
+    vn_encode_VkPipelineDynamicStateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineDynamicStateCreateInfo_self(enc, val);
+}
+
+/* struct VkGraphicsPipelineCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkGraphicsPipelineCreateInfo_self(const VkGraphicsPipelineCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->stageCount);
+    if (val->pStages) {
+        size += vn_sizeof_array_size(val->stageCount);
+        for (uint32_t i = 0; i < val->stageCount; i++)
+            size += vn_sizeof_VkPipelineShaderStageCreateInfo(&val->pStages[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_simple_pointer(val->pVertexInputState);
+    if (val->pVertexInputState)
+        size += vn_sizeof_VkPipelineVertexInputStateCreateInfo(val->pVertexInputState);
+    size += vn_sizeof_simple_pointer(val->pInputAssemblyState);
+    if (val->pInputAssemblyState)
+        size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(val->pInputAssemblyState);
+    size += vn_sizeof_simple_pointer(val->pTessellationState);
+    if (val->pTessellationState)
+        size += vn_sizeof_VkPipelineTessellationStateCreateInfo(val->pTessellationState);
+    size += vn_sizeof_simple_pointer(val->pViewportState);
+    if (val->pViewportState)
+        size += vn_sizeof_VkPipelineViewportStateCreateInfo(val->pViewportState);
+    size += vn_sizeof_simple_pointer(val->pRasterizationState);
+    if (val->pRasterizationState)
+        size += vn_sizeof_VkPipelineRasterizationStateCreateInfo(val->pRasterizationState);
+    size += vn_sizeof_simple_pointer(val->pMultisampleState);
+    if (val->pMultisampleState)
+        size += vn_sizeof_VkPipelineMultisampleStateCreateInfo(val->pMultisampleState);
+    size += vn_sizeof_simple_pointer(val->pDepthStencilState);
+    if (val->pDepthStencilState)
+        size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo(val->pDepthStencilState);
+    size += vn_sizeof_simple_pointer(val->pColorBlendState);
+    if (val->pColorBlendState)
+        size += vn_sizeof_VkPipelineColorBlendStateCreateInfo(val->pColorBlendState);
+    size += vn_sizeof_simple_pointer(val->pDynamicState);
+    if (val->pDynamicState)
+        size += vn_sizeof_VkPipelineDynamicStateCreateInfo(val->pDynamicState);
+    size += vn_sizeof_VkPipelineLayout(&val->layout);
+    size += vn_sizeof_VkRenderPass(&val->renderPass);
+    size += vn_sizeof_uint32_t(&val->subpass);
+    size += vn_sizeof_VkPipeline(&val->basePipelineHandle);
+    size += vn_sizeof_int32_t(&val->basePipelineIndex);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkGraphicsPipelineCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkGraphicsPipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkGraphicsPipelineCreateInfo_self(struct vn_cs_encoder *enc, const VkGraphicsPipelineCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->stageCount);
+    if (val->pStages) {
+        vn_encode_array_size(enc, val->stageCount);
+        for (uint32_t i = 0; i < val->stageCount; i++)
+            vn_encode_VkPipelineShaderStageCreateInfo(enc, &val->pStages[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (vn_encode_simple_pointer(enc, val->pVertexInputState))
+        vn_encode_VkPipelineVertexInputStateCreateInfo(enc, val->pVertexInputState);
+    if (vn_encode_simple_pointer(enc, val->pInputAssemblyState))
+        vn_encode_VkPipelineInputAssemblyStateCreateInfo(enc, val->pInputAssemblyState);
+    if (vn_encode_simple_pointer(enc, val->pTessellationState))
+        vn_encode_VkPipelineTessellationStateCreateInfo(enc, val->pTessellationState);
+    if (vn_encode_simple_pointer(enc, val->pViewportState))
+        vn_encode_VkPipelineViewportStateCreateInfo(enc, val->pViewportState);
+    if (vn_encode_simple_pointer(enc, val->pRasterizationState))
+        vn_encode_VkPipelineRasterizationStateCreateInfo(enc, val->pRasterizationState);
+    if (vn_encode_simple_pointer(enc, val->pMultisampleState))
+        vn_encode_VkPipelineMultisampleStateCreateInfo(enc, val->pMultisampleState);
+    if (vn_encode_simple_pointer(enc, val->pDepthStencilState))
+        vn_encode_VkPipelineDepthStencilStateCreateInfo(enc, val->pDepthStencilState);
+    if (vn_encode_simple_pointer(enc, val->pColorBlendState))
+        vn_encode_VkPipelineColorBlendStateCreateInfo(enc, val->pColorBlendState);
+    if (vn_encode_simple_pointer(enc, val->pDynamicState))
+        vn_encode_VkPipelineDynamicStateCreateInfo(enc, val->pDynamicState);
+    vn_encode_VkPipelineLayout(enc, &val->layout);
+    vn_encode_VkRenderPass(enc, &val->renderPass);
+    vn_encode_uint32_t(enc, &val->subpass);
+    vn_encode_VkPipeline(enc, &val->basePipelineHandle);
+    vn_encode_int32_t(enc, &val->basePipelineIndex);
+}
+
+static inline void
+vn_encode_VkGraphicsPipelineCreateInfo(struct vn_cs_encoder *enc, const VkGraphicsPipelineCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO });
+    vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkGraphicsPipelineCreateInfo_self(enc, val);
+}
+
+/* struct VkComputePipelineCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkComputePipelineCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkComputePipelineCreateInfo_self(const VkComputePipelineCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkPipelineShaderStageCreateInfo(&val->stage);
+    size += vn_sizeof_VkPipelineLayout(&val->layout);
+    size += vn_sizeof_VkPipeline(&val->basePipelineHandle);
+    size += vn_sizeof_int32_t(&val->basePipelineIndex);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkComputePipelineCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkComputePipelineCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkComputePipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkComputePipelineCreateInfo_self(struct vn_cs_encoder *enc, const VkComputePipelineCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkPipelineShaderStageCreateInfo(enc, &val->stage);
+    vn_encode_VkPipelineLayout(enc, &val->layout);
+    vn_encode_VkPipeline(enc, &val->basePipelineHandle);
+    vn_encode_int32_t(enc, &val->basePipelineIndex);
+}
+
+static inline void
+vn_encode_VkComputePipelineCreateInfo(struct vn_cs_encoder *enc, const VkComputePipelineCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO });
+    vn_encode_VkComputePipelineCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkComputePipelineCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
+    cmd_size += vn_sizeof_uint32_t(&createInfoCount);
+    if (pCreateInfos) {
+        cmd_size += vn_sizeof_array_size(createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            cmd_size += vn_sizeof_VkGraphicsPipelineCreateInfo(&pCreateInfos[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    if (pPipelines) {
+        cmd_size += vn_sizeof_array_size(createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateGraphicsPipelines(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipelineCache(enc, &pipelineCache);
+    vn_encode_uint32_t(enc, &createInfoCount);
+    if (pCreateInfos) {
+        vn_encode_array_size(enc, createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            vn_encode_VkGraphicsPipelineCreateInfo(enc, &pCreateInfos[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (pPipelines) {
+        vn_encode_array_size(enc, createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            vn_encode_VkPipeline(enc, &pPipelines[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCreateGraphicsPipelines_reply(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pipelineCache */
+    /* skip createInfoCount */
+    /* skip pCreateInfos */
+    /* skip pAllocator */
+    if (pPipelines) {
+        cmd_size += vn_sizeof_array_size(createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateGraphicsPipelines_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pipelineCache */
+    /* skip createInfoCount */
+    /* skip pCreateInfos */
+    /* skip pAllocator */
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            vn_decode_VkPipeline(dec, &pPipelines[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pPipelines = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
+    cmd_size += vn_sizeof_uint32_t(&createInfoCount);
+    if (pCreateInfos) {
+        cmd_size += vn_sizeof_array_size(createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            cmd_size += vn_sizeof_VkComputePipelineCreateInfo(&pCreateInfos[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    if (pPipelines) {
+        cmd_size += vn_sizeof_array_size(createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateComputePipelines(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipelineCache(enc, &pipelineCache);
+    vn_encode_uint32_t(enc, &createInfoCount);
+    if (pCreateInfos) {
+        vn_encode_array_size(enc, createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            vn_encode_VkComputePipelineCreateInfo(enc, &pCreateInfos[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (pPipelines) {
+        vn_encode_array_size(enc, createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            vn_encode_VkPipeline(enc, &pPipelines[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkCreateComputePipelines_reply(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pipelineCache */
+    /* skip createInfoCount */
+    /* skip pCreateInfos */
+    /* skip pAllocator */
+    if (pPipelines) {
+        cmd_size += vn_sizeof_array_size(createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateComputePipelines_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateComputePipelines_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pipelineCache */
+    /* skip createInfoCount */
+    /* skip pCreateInfos */
+    /* skip pAllocator */
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, createInfoCount);
+        for (uint32_t i = 0; i < createInfoCount; i++)
+            vn_decode_VkPipeline(dec, &pPipelines[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pPipelines = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipeline(&pipeline);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyPipeline(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipeline(enc, &pipeline);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyPipeline_reply(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pipeline */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyPipeline_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyPipeline_EXT);
+
+    /* skip device */
+    /* skip pipeline */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateGraphicsPipelines(&submit->command, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateGraphicsPipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCreateComputePipelines(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateComputePipelines(&submit->command, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateComputePipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyPipeline(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyPipeline(device, pipeline, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyPipeline(&submit->command, cmd_flags, device, pipeline, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipeline_reply(device, pipeline, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateGraphicsPipelines(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateGraphicsPipelines_reply(&submit.reply, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateGraphicsPipelines(vn_instance, 0, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
+}
+
+static inline VkResult vn_call_vkCreateComputePipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateComputePipelines(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateComputePipelines_reply(&submit.reply, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateComputePipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateComputePipelines(vn_instance, 0, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
+}
+
+static inline void vn_call_vkDestroyPipeline(struct vn_instance *vn_instance, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyPipeline(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipeline, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyPipeline_reply(&submit.reply, device, pipeline, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyPipeline(struct vn_instance *vn_instance, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyPipeline(vn_instance, 0, device, pipeline, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_PIPELINE_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_pipeline_cache.h b/src/virtio/venus-protocol/vn_protocol_driver_pipeline_cache.h
new file mode 100644 (file)
index 0000000..1a2e097
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_pipeline_cache.h
@@ -0,0 +1,510 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_PIPELINE_CACHE_H
+#define VN_PROTOCOL_DRIVER_PIPELINE_CACHE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkPipelineCacheCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineCacheCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineCacheCreateInfo_self(const VkPipelineCacheCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_size_t(&val->initialDataSize);
+    if (val->pInitialData) {
+        size += vn_sizeof_array_size(val->initialDataSize);
+        size += vn_sizeof_blob_array(val->pInitialData, val->initialDataSize);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineCacheCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineCacheCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineCacheCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineCacheCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineCacheCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_size_t(enc, &val->initialDataSize);
+    if (val->pInitialData) {
+        vn_encode_array_size(enc, val->initialDataSize);
+        vn_encode_blob_array(enc, val->pInitialData, val->initialDataSize);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkPipelineCacheCreateInfo(struct vn_cs_encoder *enc, const VkPipelineCacheCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO });
+    vn_encode_VkPipelineCacheCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineCacheCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkPipelineCacheCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pPipelineCache);
+    if (pPipelineCache)
+        cmd_size += vn_sizeof_VkPipelineCache(pPipelineCache);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreatePipelineCache(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkPipelineCacheCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pPipelineCache))
+        vn_encode_VkPipelineCache(enc, pPipelineCache);
+}
+
+static inline size_t vn_sizeof_vkCreatePipelineCache_reply(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pPipelineCache);
+    if (pPipelineCache)
+        cmd_size += vn_sizeof_VkPipelineCache(pPipelineCache);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreatePipelineCache_reply(struct vn_cs_decoder *dec, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreatePipelineCache_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkPipelineCache(dec, pPipelineCache);
+    } else {
+        pPipelineCache = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyPipelineCache(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipelineCache(enc, &pipelineCache);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyPipelineCache_reply(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pipelineCache */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyPipelineCache_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT);
+
+    /* skip device */
+    /* skip pipelineCache */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
+    cmd_size += vn_sizeof_simple_pointer(pDataSize);
+    if (pDataSize)
+        cmd_size += vn_sizeof_size_t(pDataSize);
+    cmd_size += vn_sizeof_simple_pointer(pData); /* out */
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPipelineCacheData(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipelineCache(enc, &pipelineCache);
+    if (vn_encode_simple_pointer(enc, pDataSize))
+        vn_encode_size_t(enc, pDataSize);
+    vn_encode_array_size(enc, pData ? *pDataSize : 0); /* out */
+}
+
+static inline size_t vn_sizeof_vkGetPipelineCacheData_reply(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pipelineCache */
+    cmd_size += vn_sizeof_simple_pointer(pDataSize);
+    if (pDataSize)
+        cmd_size += vn_sizeof_size_t(pDataSize);
+    if (pData) {
+        cmd_size += vn_sizeof_array_size(*pDataSize);
+        cmd_size += vn_sizeof_blob_array(pData, *pDataSize);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetPipelineCacheData_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pipelineCache */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_size_t(dec, pDataSize);
+    } else {
+        pDataSize = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        const size_t array_size = vn_decode_array_size(dec, *pDataSize);
+        vn_decode_blob_array(dec, pData, array_size);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pData = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipelineCache(&dstCache);
+    cmd_size += vn_sizeof_uint32_t(&srcCacheCount);
+    if (pSrcCaches) {
+        cmd_size += vn_sizeof_array_size(srcCacheCount);
+        for (uint32_t i = 0; i < srcCacheCount; i++)
+            cmd_size += vn_sizeof_VkPipelineCache(&pSrcCaches[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkMergePipelineCaches(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipelineCache(enc, &dstCache);
+    vn_encode_uint32_t(enc, &srcCacheCount);
+    if (pSrcCaches) {
+        vn_encode_array_size(enc, srcCacheCount);
+        for (uint32_t i = 0; i < srcCacheCount; i++)
+            vn_encode_VkPipelineCache(enc, &pSrcCaches[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkMergePipelineCaches_reply(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip dstCache */
+    /* skip srcCacheCount */
+    /* skip pSrcCaches */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkMergePipelineCaches_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkMergePipelineCaches_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip dstCache */
+    /* skip srcCacheCount */
+    /* skip pSrcCaches */
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreatePipelineCache(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreatePipelineCache(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pPipelineCache);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineCache_reply(device, pCreateInfo, pAllocator, pPipelineCache) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyPipelineCache(device, pipelineCache, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyPipelineCache(&submit->command, cmd_flags, device, pipelineCache, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineCache_reply(device, pipelineCache, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPipelineCacheData(&submit->command, cmd_flags, device, pipelineCache, pDataSize, pData);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPipelineCacheData_reply(device, pipelineCache, pDataSize, pData) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkMergePipelineCaches(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkMergePipelineCaches(&submit->command, cmd_flags, device, dstCache, srcCacheCount, pSrcCaches);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkMergePipelineCaches_reply(device, dstCache, srcCacheCount, pSrcCaches) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreatePipelineCache(struct vn_instance *vn_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreatePipelineCache(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPipelineCache, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreatePipelineCache_reply(&submit.reply, device, pCreateInfo, pAllocator, pPipelineCache);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreatePipelineCache(struct vn_instance *vn_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreatePipelineCache(vn_instance, 0, device, pCreateInfo, pAllocator, pPipelineCache, &submit);
+}
+
+static inline void vn_call_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyPipelineCache(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyPipelineCache_reply(&submit.reply, device, pipelineCache, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyPipelineCache(vn_instance, 0, device, pipelineCache, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPipelineCacheData(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, pDataSize, pData, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetPipelineCacheData_reply(&submit.reply, device, pipelineCache, pDataSize, pData);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPipelineCacheData(vn_instance, 0, device, pipelineCache, pDataSize, pData, &submit);
+}
+
+static inline VkResult vn_call_vkMergePipelineCaches(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkMergePipelineCaches(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, dstCache, srcCacheCount, pSrcCaches, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkMergePipelineCaches_reply(&submit.reply, device, dstCache, srcCacheCount, pSrcCaches);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkMergePipelineCaches(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkMergePipelineCaches(vn_instance, 0, device, dstCache, srcCacheCount, pSrcCaches, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_PIPELINE_CACHE_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_pipeline_layout.h b/src/virtio/venus-protocol/vn_protocol_driver_pipeline_layout.h
new file mode 100644 (file)
index 0000000..2e86797
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_pipeline_layout.h
@@ -0,0 +1,320 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_PIPELINE_LAYOUT_H
+#define VN_PROTOCOL_DRIVER_PIPELINE_LAYOUT_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkPushConstantRange */
+
+static inline size_t
+vn_sizeof_VkPushConstantRange(const VkPushConstantRange *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->stageFlags);
+    size += vn_sizeof_uint32_t(&val->offset);
+    size += vn_sizeof_uint32_t(&val->size);
+    return size;
+}
+
+static inline void
+vn_encode_VkPushConstantRange(struct vn_cs_encoder *enc, const VkPushConstantRange *val)
+{
+    vn_encode_VkFlags(enc, &val->stageFlags);
+    vn_encode_uint32_t(enc, &val->offset);
+    vn_encode_uint32_t(enc, &val->size);
+}
+
+/* struct VkPipelineLayoutCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineLayoutCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineLayoutCreateInfo_self(const VkPipelineLayoutCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->setLayoutCount);
+    if (val->pSetLayouts) {
+        size += vn_sizeof_array_size(val->setLayoutCount);
+        for (uint32_t i = 0; i < val->setLayoutCount; i++)
+            size += vn_sizeof_VkDescriptorSetLayout(&val->pSetLayouts[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->pushConstantRangeCount);
+    if (val->pPushConstantRanges) {
+        size += vn_sizeof_array_size(val->pushConstantRangeCount);
+        for (uint32_t i = 0; i < val->pushConstantRangeCount; i++)
+            size += vn_sizeof_VkPushConstantRange(&val->pPushConstantRanges[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineLayoutCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineLayoutCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineLayoutCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineLayoutCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineLayoutCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->setLayoutCount);
+    if (val->pSetLayouts) {
+        vn_encode_array_size(enc, val->setLayoutCount);
+        for (uint32_t i = 0; i < val->setLayoutCount; i++)
+            vn_encode_VkDescriptorSetLayout(enc, &val->pSetLayouts[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->pushConstantRangeCount);
+    if (val->pPushConstantRanges) {
+        vn_encode_array_size(enc, val->pushConstantRangeCount);
+        for (uint32_t i = 0; i < val->pushConstantRangeCount; i++)
+            vn_encode_VkPushConstantRange(enc, &val->pPushConstantRanges[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkPipelineLayoutCreateInfo(struct vn_cs_encoder *enc, const VkPipelineLayoutCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO });
+    vn_encode_VkPipelineLayoutCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineLayoutCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkPipelineLayoutCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pPipelineLayout);
+    if (pPipelineLayout)
+        cmd_size += vn_sizeof_VkPipelineLayout(pPipelineLayout);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreatePipelineLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkPipelineLayoutCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pPipelineLayout))
+        vn_encode_VkPipelineLayout(enc, pPipelineLayout);
+}
+
+static inline size_t vn_sizeof_vkCreatePipelineLayout_reply(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pPipelineLayout);
+    if (pPipelineLayout)
+        cmd_size += vn_sizeof_VkPipelineLayout(pPipelineLayout);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreatePipelineLayout_reply(struct vn_cs_decoder *dec, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkPipelineLayout(dec, pPipelineLayout);
+    } else {
+        pPipelineLayout = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipelineLayout(&pipelineLayout);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyPipelineLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipelineLayout(enc, &pipelineLayout);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyPipelineLayout_reply(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pipelineLayout */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyPipelineLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT);
+
+    /* skip device */
+    /* skip pipelineLayout */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreatePipelineLayout(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pPipelineLayout);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineLayout_reply(device, pCreateInfo, pAllocator, pPipelineLayout) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyPipelineLayout(&submit->command, cmd_flags, device, pipelineLayout, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineLayout_reply(device, pipelineLayout, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreatePipelineLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPipelineLayout, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreatePipelineLayout_reply(&submit.reply, device, pCreateInfo, pAllocator, pPipelineLayout);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreatePipelineLayout(vn_instance, 0, device, pCreateInfo, pAllocator, pPipelineLayout, &submit);
+}
+
+static inline void vn_call_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyPipelineLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineLayout, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyPipelineLayout_reply(&submit.reply, device, pipelineLayout, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyPipelineLayout(vn_instance, 0, device, pipelineLayout, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_PIPELINE_LAYOUT_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_query_pool.h b/src/virtio/venus-protocol/vn_protocol_driver_query_pool.h
new file mode 100644 (file)
index 0000000..f2911ed
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_query_pool.h
@@ -0,0 +1,488 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_QUERY_POOL_H
+#define VN_PROTOCOL_DRIVER_QUERY_POOL_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkQueryPoolCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkQueryPoolCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkQueryPoolCreateInfo_self(const VkQueryPoolCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkQueryType(&val->queryType);
+    size += vn_sizeof_uint32_t(&val->queryCount);
+    size += vn_sizeof_VkFlags(&val->pipelineStatistics);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkQueryPoolCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkQueryPoolCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkQueryPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkQueryPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkQueryPoolCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkQueryType(enc, &val->queryType);
+    vn_encode_uint32_t(enc, &val->queryCount);
+    vn_encode_VkFlags(enc, &val->pipelineStatistics);
+}
+
+static inline void
+vn_encode_VkQueryPoolCreateInfo(struct vn_cs_encoder *enc, const VkQueryPoolCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO });
+    vn_encode_VkQueryPoolCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkQueryPoolCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkQueryPoolCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pQueryPool);
+    if (pQueryPool)
+        cmd_size += vn_sizeof_VkQueryPool(pQueryPool);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkQueryPoolCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pQueryPool))
+        vn_encode_VkQueryPool(enc, pQueryPool);
+}
+
+static inline size_t vn_sizeof_vkCreateQueryPool_reply(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pQueryPool);
+    if (pQueryPool)
+        cmd_size += vn_sizeof_VkQueryPool(pQueryPool);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateQueryPool_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkQueryPool(dec, pQueryPool);
+    } else {
+        pQueryPool = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyQueryPool_reply(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip queryPool */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyQueryPool_EXT);
+
+    /* skip device */
+    /* skip queryPool */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&firstQuery);
+    cmd_size += vn_sizeof_uint32_t(&queryCount);
+    cmd_size += vn_sizeof_size_t(&dataSize);
+    cmd_size += vn_sizeof_simple_pointer(pData); /* out */
+    cmd_size += vn_sizeof_VkDeviceSize(&stride);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetQueryPoolResults(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &firstQuery);
+    vn_encode_uint32_t(enc, &queryCount);
+    vn_encode_size_t(enc, &dataSize);
+    vn_encode_array_size(enc, pData ? dataSize : 0); /* out */
+    vn_encode_VkDeviceSize(enc, &stride);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkGetQueryPoolResults_reply(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+    /* skip dataSize */
+    if (pData) {
+        cmd_size += vn_sizeof_array_size(dataSize);
+        cmd_size += vn_sizeof_blob_array(pData, dataSize);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    /* skip stride */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetQueryPoolResults_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+    /* skip dataSize */
+    if (vn_peek_array_size(dec)) {
+        const size_t array_size = vn_decode_array_size(dec, dataSize);
+        vn_decode_blob_array(dec, pData, array_size);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pData = NULL;
+    }
+    /* skip stride */
+    /* skip flags */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&firstQuery);
+    cmd_size += vn_sizeof_uint32_t(&queryCount);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &firstQuery);
+    vn_encode_uint32_t(enc, &queryCount);
+}
+
+static inline size_t vn_sizeof_vkResetQueryPool_reply(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkResetQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetQueryPool_EXT);
+
+    /* skip device */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+}
+
+static inline void vn_submit_vkCreateQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateQueryPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pQueryPool);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateQueryPool_reply(device, pCreateInfo, pAllocator, pQueryPool) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyQueryPool(device, queryPool, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyQueryPool(&submit->command, cmd_flags, device, queryPool, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyQueryPool_reply(device, queryPool, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetQueryPoolResults(&submit->command, cmd_flags, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetQueryPoolResults_reply(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetQueryPool(device, queryPool, firstQuery, queryCount);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetQueryPool(&submit->command, cmd_flags, device, queryPool, firstQuery, queryCount);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetQueryPool_reply(device, queryPool, firstQuery, queryCount) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateQueryPool(struct vn_instance *vn_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pQueryPool, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateQueryPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pQueryPool);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateQueryPool(struct vn_instance *vn_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateQueryPool(vn_instance, 0, device, pCreateInfo, pAllocator, pQueryPool, &submit);
+}
+
+static inline void vn_call_vkDestroyQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyQueryPool_reply(&submit.reply, device, queryPool, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyQueryPool(vn_instance, 0, device, queryPool, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetQueryPoolResults(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetQueryPoolResults_reply(&submit.reply, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetQueryPoolResults(vn_instance, 0, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, &submit);
+}
+
+static inline void vn_call_vkResetQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, firstQuery, queryCount, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkResetQueryPool_reply(&submit.reply, device, queryPool, firstQuery, queryCount);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkResetQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetQueryPool(vn_instance, 0, device, queryPool, firstQuery, queryCount, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_QUERY_POOL_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_queue.h b/src/virtio/venus-protocol/vn_protocol_driver_queue.h
new file mode 100644 (file)
index 0000000..1c0e8d2
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_queue.h
@@ -0,0 +1,1092 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_QUEUE_H
+#define VN_PROTOCOL_DRIVER_QUEUE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkDeviceGroupSubmitInfo chain */
+
+static inline size_t
+vn_sizeof_VkDeviceGroupSubmitInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDeviceGroupSubmitInfo_self(const VkDeviceGroupSubmitInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->waitSemaphoreCount);
+    if (val->pWaitSemaphoreDeviceIndices) {
+        size += vn_sizeof_array_size(val->waitSemaphoreCount);
+        size += vn_sizeof_uint32_t_array(val->pWaitSemaphoreDeviceIndices, val->waitSemaphoreCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->commandBufferCount);
+    if (val->pCommandBufferDeviceMasks) {
+        size += vn_sizeof_array_size(val->commandBufferCount);
+        size += vn_sizeof_uint32_t_array(val->pCommandBufferDeviceMasks, val->commandBufferCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->signalSemaphoreCount);
+    if (val->pSignalSemaphoreDeviceIndices) {
+        size += vn_sizeof_array_size(val->signalSemaphoreCount);
+        size += vn_sizeof_uint32_t_array(val->pSignalSemaphoreDeviceIndices, val->signalSemaphoreCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDeviceGroupSubmitInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDeviceGroupSubmitInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDeviceGroupSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDeviceGroupSubmitInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupSubmitInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->waitSemaphoreCount);
+    if (val->pWaitSemaphoreDeviceIndices) {
+        vn_encode_array_size(enc, val->waitSemaphoreCount);
+        vn_encode_uint32_t_array(enc, val->pWaitSemaphoreDeviceIndices, val->waitSemaphoreCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->commandBufferCount);
+    if (val->pCommandBufferDeviceMasks) {
+        vn_encode_array_size(enc, val->commandBufferCount);
+        vn_encode_uint32_t_array(enc, val->pCommandBufferDeviceMasks, val->commandBufferCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->signalSemaphoreCount);
+    if (val->pSignalSemaphoreDeviceIndices) {
+        vn_encode_array_size(enc, val->signalSemaphoreCount);
+        vn_encode_uint32_t_array(enc, val->pSignalSemaphoreDeviceIndices, val->signalSemaphoreCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDeviceGroupSubmitInfo(struct vn_cs_encoder *enc, const VkDeviceGroupSubmitInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO });
+    vn_encode_VkDeviceGroupSubmitInfo_pnext(enc, val->pNext);
+    vn_encode_VkDeviceGroupSubmitInfo_self(enc, val);
+}
+
+/* struct VkProtectedSubmitInfo chain */
+
+static inline size_t
+vn_sizeof_VkProtectedSubmitInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkProtectedSubmitInfo_self(const VkProtectedSubmitInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->protectedSubmit);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkProtectedSubmitInfo(const VkProtectedSubmitInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkProtectedSubmitInfo_pnext(val->pNext);
+    size += vn_sizeof_VkProtectedSubmitInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkProtectedSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkProtectedSubmitInfo_self(struct vn_cs_encoder *enc, const VkProtectedSubmitInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkBool32(enc, &val->protectedSubmit);
+}
+
+static inline void
+vn_encode_VkProtectedSubmitInfo(struct vn_cs_encoder *enc, const VkProtectedSubmitInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO });
+    vn_encode_VkProtectedSubmitInfo_pnext(enc, val->pNext);
+    vn_encode_VkProtectedSubmitInfo_self(enc, val);
+}
+
+/* struct VkTimelineSemaphoreSubmitInfo chain */
+
+static inline size_t
+vn_sizeof_VkTimelineSemaphoreSubmitInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkTimelineSemaphoreSubmitInfo_self(const VkTimelineSemaphoreSubmitInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->waitSemaphoreValueCount);
+    if (val->pWaitSemaphoreValues) {
+        size += vn_sizeof_array_size(val->waitSemaphoreValueCount);
+        size += vn_sizeof_uint64_t_array(val->pWaitSemaphoreValues, val->waitSemaphoreValueCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->signalSemaphoreValueCount);
+    if (val->pSignalSemaphoreValues) {
+        size += vn_sizeof_array_size(val->signalSemaphoreValueCount);
+        size += vn_sizeof_uint64_t_array(val->pSignalSemaphoreValues, val->signalSemaphoreValueCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_pnext(val->pNext);
+    size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkTimelineSemaphoreSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkTimelineSemaphoreSubmitInfo_self(struct vn_cs_encoder *enc, const VkTimelineSemaphoreSubmitInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->waitSemaphoreValueCount);
+    if (val->pWaitSemaphoreValues) {
+        vn_encode_array_size(enc, val->waitSemaphoreValueCount);
+        vn_encode_uint64_t_array(enc, val->pWaitSemaphoreValues, val->waitSemaphoreValueCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->signalSemaphoreValueCount);
+    if (val->pSignalSemaphoreValues) {
+        vn_encode_array_size(enc, val->signalSemaphoreValueCount);
+        vn_encode_uint64_t_array(enc, val->pSignalSemaphoreValues, val->signalSemaphoreValueCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkTimelineSemaphoreSubmitInfo(struct vn_cs_encoder *enc, const VkTimelineSemaphoreSubmitInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO });
+    vn_encode_VkTimelineSemaphoreSubmitInfo_pnext(enc, val->pNext);
+    vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, val);
+}
+
+/* struct VkSubmitInfo chain */
+
+static inline size_t
+vn_sizeof_VkSubmitInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkDeviceGroupSubmitInfo_self((const VkDeviceGroupSubmitInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkProtectedSubmitInfo_self((const VkProtectedSubmitInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self((const VkTimelineSemaphoreSubmitInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSubmitInfo_self(const VkSubmitInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->waitSemaphoreCount);
+    if (val->pWaitSemaphores) {
+        size += vn_sizeof_array_size(val->waitSemaphoreCount);
+        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
+            size += vn_sizeof_VkSemaphore(&val->pWaitSemaphores[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    if (val->pWaitDstStageMask) {
+        size += vn_sizeof_array_size(val->waitSemaphoreCount);
+        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
+            size += vn_sizeof_VkFlags(&val->pWaitDstStageMask[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->commandBufferCount);
+    if (val->pCommandBuffers) {
+        size += vn_sizeof_array_size(val->commandBufferCount);
+        for (uint32_t i = 0; i < val->commandBufferCount; i++)
+            size += vn_sizeof_VkCommandBuffer(&val->pCommandBuffers[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->signalSemaphoreCount);
+    if (val->pSignalSemaphores) {
+        size += vn_sizeof_array_size(val->signalSemaphoreCount);
+        for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
+            size += vn_sizeof_VkSemaphore(&val->pSignalSemaphores[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSubmitInfo(const VkSubmitInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSubmitInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSubmitInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkDeviceGroupSubmitInfo_self(enc, (const VkDeviceGroupSubmitInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkProtectedSubmitInfo_self(enc, (const VkProtectedSubmitInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, (const VkTimelineSemaphoreSubmitInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSubmitInfo_self(struct vn_cs_encoder *enc, const VkSubmitInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->waitSemaphoreCount);
+    if (val->pWaitSemaphores) {
+        vn_encode_array_size(enc, val->waitSemaphoreCount);
+        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
+            vn_encode_VkSemaphore(enc, &val->pWaitSemaphores[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (val->pWaitDstStageMask) {
+        vn_encode_array_size(enc, val->waitSemaphoreCount);
+        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
+            vn_encode_VkFlags(enc, &val->pWaitDstStageMask[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->commandBufferCount);
+    if (val->pCommandBuffers) {
+        vn_encode_array_size(enc, val->commandBufferCount);
+        for (uint32_t i = 0; i < val->commandBufferCount; i++)
+            vn_encode_VkCommandBuffer(enc, &val->pCommandBuffers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->signalSemaphoreCount);
+    if (val->pSignalSemaphores) {
+        vn_encode_array_size(enc, val->signalSemaphoreCount);
+        for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
+            vn_encode_VkSemaphore(enc, &val->pSignalSemaphores[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkSubmitInfo(struct vn_cs_encoder *enc, const VkSubmitInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SUBMIT_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBMIT_INFO });
+    vn_encode_VkSubmitInfo_pnext(enc, val->pNext);
+    vn_encode_VkSubmitInfo_self(enc, val);
+}
+
+/* struct VkSparseMemoryBind */
+
+static inline size_t
+vn_sizeof_VkSparseMemoryBind(const VkSparseMemoryBind *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkDeviceSize(&val->resourceOffset);
+    size += vn_sizeof_VkDeviceSize(&val->size);
+    size += vn_sizeof_VkDeviceMemory(&val->memory);
+    size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
+    size += vn_sizeof_VkFlags(&val->flags);
+    return size;
+}
+
+static inline void
+vn_encode_VkSparseMemoryBind(struct vn_cs_encoder *enc, const VkSparseMemoryBind *val)
+{
+    vn_encode_VkDeviceSize(enc, &val->resourceOffset);
+    vn_encode_VkDeviceSize(enc, &val->size);
+    vn_encode_VkDeviceMemory(enc, &val->memory);
+    vn_encode_VkDeviceSize(enc, &val->memoryOffset);
+    vn_encode_VkFlags(enc, &val->flags);
+}
+
+/* struct VkSparseBufferMemoryBindInfo */
+
+static inline size_t
+vn_sizeof_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkBuffer(&val->buffer);
+    size += vn_sizeof_uint32_t(&val->bindCount);
+    if (val->pBinds) {
+        size += vn_sizeof_array_size(val->bindCount);
+        for (uint32_t i = 0; i < val->bindCount; i++)
+            size += vn_sizeof_VkSparseMemoryBind(&val->pBinds[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline void
+vn_encode_VkSparseBufferMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseBufferMemoryBindInfo *val)
+{
+    vn_encode_VkBuffer(enc, &val->buffer);
+    vn_encode_uint32_t(enc, &val->bindCount);
+    if (val->pBinds) {
+        vn_encode_array_size(enc, val->bindCount);
+        for (uint32_t i = 0; i < val->bindCount; i++)
+            vn_encode_VkSparseMemoryBind(enc, &val->pBinds[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+/* struct VkSparseImageOpaqueMemoryBindInfo */
+
+static inline size_t
+vn_sizeof_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkImage(&val->image);
+    size += vn_sizeof_uint32_t(&val->bindCount);
+    if (val->pBinds) {
+        size += vn_sizeof_array_size(val->bindCount);
+        for (uint32_t i = 0; i < val->bindCount; i++)
+            size += vn_sizeof_VkSparseMemoryBind(&val->pBinds[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline void
+vn_encode_VkSparseImageOpaqueMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseImageOpaqueMemoryBindInfo *val)
+{
+    vn_encode_VkImage(enc, &val->image);
+    vn_encode_uint32_t(enc, &val->bindCount);
+    if (val->pBinds) {
+        vn_encode_array_size(enc, val->bindCount);
+        for (uint32_t i = 0; i < val->bindCount; i++)
+            vn_encode_VkSparseMemoryBind(enc, &val->pBinds[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+/* struct VkSparseImageMemoryBind */
+
+static inline size_t
+vn_sizeof_VkSparseImageMemoryBind(const VkSparseImageMemoryBind *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkImageSubresource(&val->subresource);
+    size += vn_sizeof_VkOffset3D(&val->offset);
+    size += vn_sizeof_VkExtent3D(&val->extent);
+    size += vn_sizeof_VkDeviceMemory(&val->memory);
+    size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
+    size += vn_sizeof_VkFlags(&val->flags);
+    return size;
+}
+
+static inline void
+vn_encode_VkSparseImageMemoryBind(struct vn_cs_encoder *enc, const VkSparseImageMemoryBind *val)
+{
+    vn_encode_VkImageSubresource(enc, &val->subresource);
+    vn_encode_VkOffset3D(enc, &val->offset);
+    vn_encode_VkExtent3D(enc, &val->extent);
+    vn_encode_VkDeviceMemory(enc, &val->memory);
+    vn_encode_VkDeviceSize(enc, &val->memoryOffset);
+    vn_encode_VkFlags(enc, &val->flags);
+}
+
+/* struct VkSparseImageMemoryBindInfo */
+
+static inline size_t
+vn_sizeof_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkImage(&val->image);
+    size += vn_sizeof_uint32_t(&val->bindCount);
+    if (val->pBinds) {
+        size += vn_sizeof_array_size(val->bindCount);
+        for (uint32_t i = 0; i < val->bindCount; i++)
+            size += vn_sizeof_VkSparseImageMemoryBind(&val->pBinds[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline void
+vn_encode_VkSparseImageMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseImageMemoryBindInfo *val)
+{
+    vn_encode_VkImage(enc, &val->image);
+    vn_encode_uint32_t(enc, &val->bindCount);
+    if (val->pBinds) {
+        vn_encode_array_size(enc, val->bindCount);
+        for (uint32_t i = 0; i < val->bindCount; i++)
+            vn_encode_VkSparseImageMemoryBind(enc, &val->pBinds[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+/* struct VkDeviceGroupBindSparseInfo chain */
+
+static inline size_t
+vn_sizeof_VkDeviceGroupBindSparseInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDeviceGroupBindSparseInfo_self(const VkDeviceGroupBindSparseInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->resourceDeviceIndex);
+    size += vn_sizeof_uint32_t(&val->memoryDeviceIndex);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDeviceGroupBindSparseInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDeviceGroupBindSparseInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDeviceGroupBindSparseInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDeviceGroupBindSparseInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupBindSparseInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->resourceDeviceIndex);
+    vn_encode_uint32_t(enc, &val->memoryDeviceIndex);
+}
+
+static inline void
+vn_encode_VkDeviceGroupBindSparseInfo(struct vn_cs_encoder *enc, const VkDeviceGroupBindSparseInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO });
+    vn_encode_VkDeviceGroupBindSparseInfo_pnext(enc, val->pNext);
+    vn_encode_VkDeviceGroupBindSparseInfo_self(enc, val);
+}
+
+/* struct VkBindSparseInfo chain */
+
+static inline size_t
+vn_sizeof_VkBindSparseInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkBindSparseInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkDeviceGroupBindSparseInfo_self((const VkDeviceGroupBindSparseInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkBindSparseInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self((const VkTimelineSemaphoreSubmitInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBindSparseInfo_self(const VkBindSparseInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->waitSemaphoreCount);
+    if (val->pWaitSemaphores) {
+        size += vn_sizeof_array_size(val->waitSemaphoreCount);
+        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
+            size += vn_sizeof_VkSemaphore(&val->pWaitSemaphores[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->bufferBindCount);
+    if (val->pBufferBinds) {
+        size += vn_sizeof_array_size(val->bufferBindCount);
+        for (uint32_t i = 0; i < val->bufferBindCount; i++)
+            size += vn_sizeof_VkSparseBufferMemoryBindInfo(&val->pBufferBinds[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->imageOpaqueBindCount);
+    if (val->pImageOpaqueBinds) {
+        size += vn_sizeof_array_size(val->imageOpaqueBindCount);
+        for (uint32_t i = 0; i < val->imageOpaqueBindCount; i++)
+            size += vn_sizeof_VkSparseImageOpaqueMemoryBindInfo(&val->pImageOpaqueBinds[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->imageBindCount);
+    if (val->pImageBinds) {
+        size += vn_sizeof_array_size(val->imageBindCount);
+        for (uint32_t i = 0; i < val->imageBindCount; i++)
+            size += vn_sizeof_VkSparseImageMemoryBindInfo(&val->pImageBinds[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->signalSemaphoreCount);
+    if (val->pSignalSemaphores) {
+        size += vn_sizeof_array_size(val->signalSemaphoreCount);
+        for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
+            size += vn_sizeof_VkSemaphore(&val->pSignalSemaphores[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBindSparseInfo(const VkBindSparseInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBindSparseInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBindSparseInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBindSparseInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkBindSparseInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkDeviceGroupBindSparseInfo_self(enc, (const VkDeviceGroupBindSparseInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkBindSparseInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, (const VkTimelineSemaphoreSubmitInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBindSparseInfo_self(struct vn_cs_encoder *enc, const VkBindSparseInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->waitSemaphoreCount);
+    if (val->pWaitSemaphores) {
+        vn_encode_array_size(enc, val->waitSemaphoreCount);
+        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
+            vn_encode_VkSemaphore(enc, &val->pWaitSemaphores[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->bufferBindCount);
+    if (val->pBufferBinds) {
+        vn_encode_array_size(enc, val->bufferBindCount);
+        for (uint32_t i = 0; i < val->bufferBindCount; i++)
+            vn_encode_VkSparseBufferMemoryBindInfo(enc, &val->pBufferBinds[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->imageOpaqueBindCount);
+    if (val->pImageOpaqueBinds) {
+        vn_encode_array_size(enc, val->imageOpaqueBindCount);
+        for (uint32_t i = 0; i < val->imageOpaqueBindCount; i++)
+            vn_encode_VkSparseImageOpaqueMemoryBindInfo(enc, &val->pImageOpaqueBinds[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->imageBindCount);
+    if (val->pImageBinds) {
+        vn_encode_array_size(enc, val->imageBindCount);
+        for (uint32_t i = 0; i < val->imageBindCount; i++)
+            vn_encode_VkSparseImageMemoryBindInfo(enc, &val->pImageBinds[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->signalSemaphoreCount);
+    if (val->pSignalSemaphores) {
+        vn_encode_array_size(enc, val->signalSemaphoreCount);
+        for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
+            vn_encode_VkSemaphore(enc, &val->pSignalSemaphores[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkBindSparseInfo(struct vn_cs_encoder *enc, const VkBindSparseInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BIND_SPARSE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO });
+    vn_encode_VkBindSparseInfo_pnext(enc, val->pNext);
+    vn_encode_VkBindSparseInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkQueue(&queue);
+    cmd_size += vn_sizeof_uint32_t(&submitCount);
+    if (pSubmits) {
+        cmd_size += vn_sizeof_array_size(submitCount);
+        for (uint32_t i = 0; i < submitCount; i++)
+            cmd_size += vn_sizeof_VkSubmitInfo(&pSubmits[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_VkFence(&fence);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkQueueSubmit(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkQueue(enc, &queue);
+    vn_encode_uint32_t(enc, &submitCount);
+    if (pSubmits) {
+        vn_encode_array_size(enc, submitCount);
+        for (uint32_t i = 0; i < submitCount; i++)
+            vn_encode_VkSubmitInfo(enc, &pSubmits[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkFence(enc, &fence);
+}
+
+static inline size_t vn_sizeof_vkQueueSubmit_reply(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip queue */
+    /* skip submitCount */
+    /* skip pSubmits */
+    /* skip fence */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkQueueSubmit_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkQueueSubmit_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip queue */
+    /* skip submitCount */
+    /* skip pSubmits */
+    /* skip fence */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkQueueWaitIdle(VkQueue queue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkQueue(&queue);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkQueueWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkQueue(enc, &queue);
+}
+
+static inline size_t vn_sizeof_vkQueueWaitIdle_reply(VkQueue queue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip queue */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkQueueWaitIdle_reply(struct vn_cs_decoder *dec, VkQueue queue)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkQueueWaitIdle_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip queue */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkQueue(&queue);
+    cmd_size += vn_sizeof_uint32_t(&bindInfoCount);
+    if (pBindInfo) {
+        cmd_size += vn_sizeof_array_size(bindInfoCount);
+        for (uint32_t i = 0; i < bindInfoCount; i++)
+            cmd_size += vn_sizeof_VkBindSparseInfo(&pBindInfo[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_VkFence(&fence);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkQueueBindSparse(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkQueue(enc, &queue);
+    vn_encode_uint32_t(enc, &bindInfoCount);
+    if (pBindInfo) {
+        vn_encode_array_size(enc, bindInfoCount);
+        for (uint32_t i = 0; i < bindInfoCount; i++)
+            vn_encode_VkBindSparseInfo(enc, &pBindInfo[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkFence(enc, &fence);
+}
+
+static inline size_t vn_sizeof_vkQueueBindSparse_reply(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip queue */
+    /* skip bindInfoCount */
+    /* skip pBindInfo */
+    /* skip fence */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkQueueBindSparse_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkQueueBindSparse_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip queue */
+    /* skip bindInfoCount */
+    /* skip pBindInfo */
+    /* skip fence */
+
+    return ret;
+}
+
+static inline void vn_submit_vkQueueSubmit(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkQueueSubmit(queue, submitCount, pSubmits, fence);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkQueueSubmit(&submit->command, cmd_flags, queue, submitCount, pSubmits, fence);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueSubmit_reply(queue, submitCount, pSubmits, fence) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkQueueWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkQueueWaitIdle(queue);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkQueueWaitIdle(&submit->command, cmd_flags, queue);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueWaitIdle_reply(queue) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkQueueBindSparse(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkQueueBindSparse(&submit->command, cmd_flags, queue, bindInfoCount, pBindInfo, fence);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueBindSparse_reply(queue, bindInfoCount, pBindInfo, fence) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkQueueSubmit(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, submitCount, pSubmits, fence, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkQueueSubmit_reply(&submit.reply, queue, submitCount, pSubmits, fence);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkQueueSubmit(vn_instance, 0, queue, submitCount, pSubmits, fence, &submit);
+}
+
+static inline VkResult vn_call_vkQueueWaitIdle(struct vn_instance *vn_instance, VkQueue queue)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkQueueWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkQueueWaitIdle_reply(&submit.reply, queue);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkQueueWaitIdle(struct vn_instance *vn_instance, VkQueue queue)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkQueueWaitIdle(vn_instance, 0, queue, &submit);
+}
+
+static inline VkResult vn_call_vkQueueBindSparse(struct vn_instance *vn_instance, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkQueueBindSparse(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, bindInfoCount, pBindInfo, fence, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkQueueBindSparse_reply(&submit.reply, queue, bindInfoCount, pBindInfo, fence);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkQueueBindSparse(struct vn_instance *vn_instance, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkQueueBindSparse(vn_instance, 0, queue, bindInfoCount, pBindInfo, fence, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_QUEUE_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_render_pass.h b/src/virtio/venus-protocol/vn_protocol_driver_render_pass.h
new file mode 100644 (file)
index 0000000..3252eae
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_render_pass.h
@@ -0,0 +1,1606 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_RENDER_PASS_H
+#define VN_PROTOCOL_DRIVER_RENDER_PASS_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkAttachmentDescription */
+
+static inline size_t
+vn_sizeof_VkAttachmentDescription(const VkAttachmentDescription *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
+    size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp);
+    size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp);
+    size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp);
+    size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp);
+    size += vn_sizeof_VkImageLayout(&val->initialLayout);
+    size += vn_sizeof_VkImageLayout(&val->finalLayout);
+    return size;
+}
+
+static inline void
+vn_encode_VkAttachmentDescription(struct vn_cs_encoder *enc, const VkAttachmentDescription *val)
+{
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
+    vn_encode_VkAttachmentLoadOp(enc, &val->loadOp);
+    vn_encode_VkAttachmentStoreOp(enc, &val->storeOp);
+    vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp);
+    vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp);
+    vn_encode_VkImageLayout(enc, &val->initialLayout);
+    vn_encode_VkImageLayout(enc, &val->finalLayout);
+}
+
+/* struct VkAttachmentReference */
+
+static inline size_t
+vn_sizeof_VkAttachmentReference(const VkAttachmentReference *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->attachment);
+    size += vn_sizeof_VkImageLayout(&val->layout);
+    return size;
+}
+
+static inline void
+vn_encode_VkAttachmentReference(struct vn_cs_encoder *enc, const VkAttachmentReference *val)
+{
+    vn_encode_uint32_t(enc, &val->attachment);
+    vn_encode_VkImageLayout(enc, &val->layout);
+}
+
+/* struct VkSubpassDescription */
+
+static inline size_t
+vn_sizeof_VkSubpassDescription(const VkSubpassDescription *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);
+    size += vn_sizeof_uint32_t(&val->inputAttachmentCount);
+    if (val->pInputAttachments) {
+        size += vn_sizeof_array_size(val->inputAttachmentCount);
+        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
+            size += vn_sizeof_VkAttachmentReference(&val->pInputAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
+    if (val->pColorAttachments) {
+        size += vn_sizeof_array_size(val->colorAttachmentCount);
+        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
+            size += vn_sizeof_VkAttachmentReference(&val->pColorAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    if (val->pResolveAttachments) {
+        size += vn_sizeof_array_size(val->colorAttachmentCount);
+        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
+            size += vn_sizeof_VkAttachmentReference(&val->pResolveAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment);
+    if (val->pDepthStencilAttachment)
+        size += vn_sizeof_VkAttachmentReference(val->pDepthStencilAttachment);
+    size += vn_sizeof_uint32_t(&val->preserveAttachmentCount);
+    if (val->pPreserveAttachments) {
+        size += vn_sizeof_array_size(val->preserveAttachmentCount);
+        size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline void
+vn_encode_VkSubpassDescription(struct vn_cs_encoder *enc, const VkSubpassDescription *val)
+{
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);
+    vn_encode_uint32_t(enc, &val->inputAttachmentCount);
+    if (val->pInputAttachments) {
+        vn_encode_array_size(enc, val->inputAttachmentCount);
+        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
+            vn_encode_VkAttachmentReference(enc, &val->pInputAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->colorAttachmentCount);
+    if (val->pColorAttachments) {
+        vn_encode_array_size(enc, val->colorAttachmentCount);
+        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
+            vn_encode_VkAttachmentReference(enc, &val->pColorAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (val->pResolveAttachments) {
+        vn_encode_array_size(enc, val->colorAttachmentCount);
+        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
+            vn_encode_VkAttachmentReference(enc, &val->pResolveAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment))
+        vn_encode_VkAttachmentReference(enc, val->pDepthStencilAttachment);
+    vn_encode_uint32_t(enc, &val->preserveAttachmentCount);
+    if (val->pPreserveAttachments) {
+        vn_encode_array_size(enc, val->preserveAttachmentCount);
+        vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+/* struct VkSubpassDependency */
+
+static inline size_t
+vn_sizeof_VkSubpassDependency(const VkSubpassDependency *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->srcSubpass);
+    size += vn_sizeof_uint32_t(&val->dstSubpass);
+    size += vn_sizeof_VkFlags(&val->srcStageMask);
+    size += vn_sizeof_VkFlags(&val->dstStageMask);
+    size += vn_sizeof_VkFlags(&val->srcAccessMask);
+    size += vn_sizeof_VkFlags(&val->dstAccessMask);
+    size += vn_sizeof_VkFlags(&val->dependencyFlags);
+    return size;
+}
+
+static inline void
+vn_encode_VkSubpassDependency(struct vn_cs_encoder *enc, const VkSubpassDependency *val)
+{
+    vn_encode_uint32_t(enc, &val->srcSubpass);
+    vn_encode_uint32_t(enc, &val->dstSubpass);
+    vn_encode_VkFlags(enc, &val->srcStageMask);
+    vn_encode_VkFlags(enc, &val->dstStageMask);
+    vn_encode_VkFlags(enc, &val->srcAccessMask);
+    vn_encode_VkFlags(enc, &val->dstAccessMask);
+    vn_encode_VkFlags(enc, &val->dependencyFlags);
+}
+
+/* struct VkRenderPassMultiviewCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassMultiviewCreateInfo_self(const VkRenderPassMultiviewCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->subpassCount);
+    if (val->pViewMasks) {
+        size += vn_sizeof_array_size(val->subpassCount);
+        size += vn_sizeof_uint32_t_array(val->pViewMasks, val->subpassCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->dependencyCount);
+    if (val->pViewOffsets) {
+        size += vn_sizeof_array_size(val->dependencyCount);
+        size += vn_sizeof_int32_t_array(val->pViewOffsets, val->dependencyCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->correlationMaskCount);
+    if (val->pCorrelationMasks) {
+        size += vn_sizeof_array_size(val->correlationMaskCount);
+        size += vn_sizeof_uint32_t_array(val->pCorrelationMasks, val->correlationMaskCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkRenderPassMultiviewCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkRenderPassMultiviewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkRenderPassMultiviewCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassMultiviewCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->subpassCount);
+    if (val->pViewMasks) {
+        vn_encode_array_size(enc, val->subpassCount);
+        vn_encode_uint32_t_array(enc, val->pViewMasks, val->subpassCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->dependencyCount);
+    if (val->pViewOffsets) {
+        vn_encode_array_size(enc, val->dependencyCount);
+        vn_encode_int32_t_array(enc, val->pViewOffsets, val->dependencyCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->correlationMaskCount);
+    if (val->pCorrelationMasks) {
+        vn_encode_array_size(enc, val->correlationMaskCount);
+        vn_encode_uint32_t_array(enc, val->pCorrelationMasks, val->correlationMaskCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkRenderPassMultiviewCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassMultiviewCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO });
+    vn_encode_VkRenderPassMultiviewCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkRenderPassMultiviewCreateInfo_self(enc, val);
+}
+
+/* struct VkInputAttachmentAspectReference */
+
+static inline size_t
+vn_sizeof_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->subpass);
+    size += vn_sizeof_uint32_t(&val->inputAttachmentIndex);
+    size += vn_sizeof_VkFlags(&val->aspectMask);
+    return size;
+}
+
+static inline void
+vn_encode_VkInputAttachmentAspectReference(struct vn_cs_encoder *enc, const VkInputAttachmentAspectReference *val)
+{
+    vn_encode_uint32_t(enc, &val->subpass);
+    vn_encode_uint32_t(enc, &val->inputAttachmentIndex);
+    vn_encode_VkFlags(enc, &val->aspectMask);
+}
+
+/* struct VkRenderPassInputAttachmentAspectCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(const VkRenderPassInputAttachmentAspectCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->aspectReferenceCount);
+    if (val->pAspectReferences) {
+        size += vn_sizeof_array_size(val->aspectReferenceCount);
+        for (uint32_t i = 0; i < val->aspectReferenceCount; i++)
+            size += vn_sizeof_VkInputAttachmentAspectReference(&val->pAspectReferences[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassInputAttachmentAspectCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->aspectReferenceCount);
+    if (val->pAspectReferences) {
+        vn_encode_array_size(enc, val->aspectReferenceCount);
+        for (uint32_t i = 0; i < val->aspectReferenceCount; i++)
+            vn_encode_VkInputAttachmentAspectReference(enc, &val->pAspectReferences[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkRenderPassInputAttachmentAspectCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassInputAttachmentAspectCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO });
+    vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(enc, val);
+}
+
+/* struct VkRenderPassCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkRenderPassCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkRenderPassCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkRenderPassMultiviewCreateInfo_self((const VkRenderPassMultiviewCreateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkRenderPassCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self((const VkRenderPassInputAttachmentAspectCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassCreateInfo_self(const VkRenderPassCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->attachmentCount);
+    if (val->pAttachments) {
+        size += vn_sizeof_array_size(val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            size += vn_sizeof_VkAttachmentDescription(&val->pAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->subpassCount);
+    if (val->pSubpasses) {
+        size += vn_sizeof_array_size(val->subpassCount);
+        for (uint32_t i = 0; i < val->subpassCount; i++)
+            size += vn_sizeof_VkSubpassDescription(&val->pSubpasses[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->dependencyCount);
+    if (val->pDependencies) {
+        size += vn_sizeof_array_size(val->dependencyCount);
+        for (uint32_t i = 0; i < val->dependencyCount; i++)
+            size += vn_sizeof_VkSubpassDependency(&val->pDependencies[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassCreateInfo(const VkRenderPassCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkRenderPassCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkRenderPassCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkRenderPassCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkRenderPassCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkRenderPassMultiviewCreateInfo_self(enc, (const VkRenderPassMultiviewCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkRenderPassCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(enc, (const VkRenderPassInputAttachmentAspectCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkRenderPassCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->attachmentCount);
+    if (val->pAttachments) {
+        vn_encode_array_size(enc, val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            vn_encode_VkAttachmentDescription(enc, &val->pAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->subpassCount);
+    if (val->pSubpasses) {
+        vn_encode_array_size(enc, val->subpassCount);
+        for (uint32_t i = 0; i < val->subpassCount; i++)
+            vn_encode_VkSubpassDescription(enc, &val->pSubpasses[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->dependencyCount);
+    if (val->pDependencies) {
+        vn_encode_array_size(enc, val->dependencyCount);
+        for (uint32_t i = 0; i < val->dependencyCount; i++)
+            vn_encode_VkSubpassDependency(enc, &val->pDependencies[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkRenderPassCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO });
+    vn_encode_VkRenderPassCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkRenderPassCreateInfo_self(enc, val);
+}
+
+/* struct VkAttachmentDescriptionStencilLayout chain */
+
+static inline size_t
+vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkAttachmentDescriptionStencilLayout_self(const VkAttachmentDescriptionStencilLayout *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkImageLayout(&val->stencilInitialLayout);
+    size += vn_sizeof_VkImageLayout(&val->stencilFinalLayout);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(val->pNext);
+    size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkAttachmentDescriptionStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkAttachmentDescriptionStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkImageLayout(enc, &val->stencilInitialLayout);
+    vn_encode_VkImageLayout(enc, &val->stencilFinalLayout);
+}
+
+static inline void
+vn_encode_VkAttachmentDescriptionStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT });
+    vn_encode_VkAttachmentDescriptionStencilLayout_pnext(enc, val->pNext);
+    vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, val);
+}
+
+/* struct VkAttachmentDescription2 chain */
+
+static inline size_t
+vn_sizeof_VkAttachmentDescription2_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkAttachmentDescription2_pnext(pnext->pNext);
+            size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self((const VkAttachmentDescriptionStencilLayout *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkAttachmentDescription2_self(const VkAttachmentDescription2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
+    size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp);
+    size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp);
+    size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp);
+    size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp);
+    size += vn_sizeof_VkImageLayout(&val->initialLayout);
+    size += vn_sizeof_VkImageLayout(&val->finalLayout);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkAttachmentDescription2(const VkAttachmentDescription2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkAttachmentDescription2_pnext(val->pNext);
+    size += vn_sizeof_VkAttachmentDescription2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkAttachmentDescription2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkAttachmentDescription2_pnext(enc, pnext->pNext);
+            vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, (const VkAttachmentDescriptionStencilLayout *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkAttachmentDescription2_self(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
+    vn_encode_VkAttachmentLoadOp(enc, &val->loadOp);
+    vn_encode_VkAttachmentStoreOp(enc, &val->storeOp);
+    vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp);
+    vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp);
+    vn_encode_VkImageLayout(enc, &val->initialLayout);
+    vn_encode_VkImageLayout(enc, &val->finalLayout);
+}
+
+static inline void
+vn_encode_VkAttachmentDescription2(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 });
+    vn_encode_VkAttachmentDescription2_pnext(enc, val->pNext);
+    vn_encode_VkAttachmentDescription2_self(enc, val);
+}
+
+/* struct VkAttachmentReferenceStencilLayout chain */
+
+static inline size_t
+vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkAttachmentReferenceStencilLayout_self(const VkAttachmentReferenceStencilLayout *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkImageLayout(&val->stencilLayout);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(val->pNext);
+    size += vn_sizeof_VkAttachmentReferenceStencilLayout_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkAttachmentReferenceStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkAttachmentReferenceStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkImageLayout(enc, &val->stencilLayout);
+}
+
+static inline void
+vn_encode_VkAttachmentReferenceStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT });
+    vn_encode_VkAttachmentReferenceStencilLayout_pnext(enc, val->pNext);
+    vn_encode_VkAttachmentReferenceStencilLayout_self(enc, val);
+}
+
+/* struct VkAttachmentReference2 chain */
+
+static inline size_t
+vn_sizeof_VkAttachmentReference2_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkAttachmentReference2_pnext(pnext->pNext);
+            size += vn_sizeof_VkAttachmentReferenceStencilLayout_self((const VkAttachmentReferenceStencilLayout *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkAttachmentReference2_self(const VkAttachmentReference2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->attachment);
+    size += vn_sizeof_VkImageLayout(&val->layout);
+    size += vn_sizeof_VkFlags(&val->aspectMask);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkAttachmentReference2(const VkAttachmentReference2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkAttachmentReference2_pnext(val->pNext);
+    size += vn_sizeof_VkAttachmentReference2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkAttachmentReference2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkAttachmentReference2_pnext(enc, pnext->pNext);
+            vn_encode_VkAttachmentReferenceStencilLayout_self(enc, (const VkAttachmentReferenceStencilLayout *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkAttachmentReference2_self(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->attachment);
+    vn_encode_VkImageLayout(enc, &val->layout);
+    vn_encode_VkFlags(enc, &val->aspectMask);
+}
+
+static inline void
+vn_encode_VkAttachmentReference2(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 });
+    vn_encode_VkAttachmentReference2_pnext(enc, val->pNext);
+    vn_encode_VkAttachmentReference2_self(enc, val);
+}
+
+/* struct VkSubpassDescriptionDepthStencilResolve chain */
+
+static inline size_t
+vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(const VkSubpassDescriptionDepthStencilResolve *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkResolveModeFlagBits(&val->depthResolveMode);
+    size += vn_sizeof_VkResolveModeFlagBits(&val->stencilResolveMode);
+    size += vn_sizeof_simple_pointer(val->pDepthStencilResolveAttachment);
+    if (val->pDepthStencilResolveAttachment)
+        size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilResolveAttachment);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(val->pNext);
+    size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSubpassDescriptionDepthStencilResolve_self(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkResolveModeFlagBits(enc, &val->depthResolveMode);
+    vn_encode_VkResolveModeFlagBits(enc, &val->stencilResolveMode);
+    if (vn_encode_simple_pointer(enc, val->pDepthStencilResolveAttachment))
+        vn_encode_VkAttachmentReference2(enc, val->pDepthStencilResolveAttachment);
+}
+
+static inline void
+vn_encode_VkSubpassDescriptionDepthStencilResolve(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE });
+    vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(enc, val->pNext);
+    vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, val);
+}
+
+/* struct VkSubpassDescription2 chain */
+
+static inline size_t
+vn_sizeof_VkSubpassDescription2_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSubpassDescription2_pnext(pnext->pNext);
+            size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self((const VkSubpassDescriptionDepthStencilResolve *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSubpassDescription2_self(const VkSubpassDescription2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);
+    size += vn_sizeof_uint32_t(&val->viewMask);
+    size += vn_sizeof_uint32_t(&val->inputAttachmentCount);
+    if (val->pInputAttachments) {
+        size += vn_sizeof_array_size(val->inputAttachmentCount);
+        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
+            size += vn_sizeof_VkAttachmentReference2(&val->pInputAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
+    if (val->pColorAttachments) {
+        size += vn_sizeof_array_size(val->colorAttachmentCount);
+        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
+            size += vn_sizeof_VkAttachmentReference2(&val->pColorAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    if (val->pResolveAttachments) {
+        size += vn_sizeof_array_size(val->colorAttachmentCount);
+        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
+            size += vn_sizeof_VkAttachmentReference2(&val->pResolveAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment);
+    if (val->pDepthStencilAttachment)
+        size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilAttachment);
+    size += vn_sizeof_uint32_t(&val->preserveAttachmentCount);
+    if (val->pPreserveAttachments) {
+        size += vn_sizeof_array_size(val->preserveAttachmentCount);
+        size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSubpassDescription2(const VkSubpassDescription2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSubpassDescription2_pnext(val->pNext);
+    size += vn_sizeof_VkSubpassDescription2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSubpassDescription2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSubpassDescription2_pnext(enc, pnext->pNext);
+            vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, (const VkSubpassDescriptionDepthStencilResolve *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSubpassDescription2_self(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);
+    vn_encode_uint32_t(enc, &val->viewMask);
+    vn_encode_uint32_t(enc, &val->inputAttachmentCount);
+    if (val->pInputAttachments) {
+        vn_encode_array_size(enc, val->inputAttachmentCount);
+        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
+            vn_encode_VkAttachmentReference2(enc, &val->pInputAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->colorAttachmentCount);
+    if (val->pColorAttachments) {
+        vn_encode_array_size(enc, val->colorAttachmentCount);
+        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
+            vn_encode_VkAttachmentReference2(enc, &val->pColorAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (val->pResolveAttachments) {
+        vn_encode_array_size(enc, val->colorAttachmentCount);
+        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
+            vn_encode_VkAttachmentReference2(enc, &val->pResolveAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment))
+        vn_encode_VkAttachmentReference2(enc, val->pDepthStencilAttachment);
+    vn_encode_uint32_t(enc, &val->preserveAttachmentCount);
+    if (val->pPreserveAttachments) {
+        vn_encode_array_size(enc, val->preserveAttachmentCount);
+        vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkSubpassDescription2(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 });
+    vn_encode_VkSubpassDescription2_pnext(enc, val->pNext);
+    vn_encode_VkSubpassDescription2_self(enc, val);
+}
+
+/* struct VkSubpassDependency2 chain */
+
+static inline size_t
+vn_sizeof_VkSubpassDependency2_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSubpassDependency2_self(const VkSubpassDependency2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->srcSubpass);
+    size += vn_sizeof_uint32_t(&val->dstSubpass);
+    size += vn_sizeof_VkFlags(&val->srcStageMask);
+    size += vn_sizeof_VkFlags(&val->dstStageMask);
+    size += vn_sizeof_VkFlags(&val->srcAccessMask);
+    size += vn_sizeof_VkFlags(&val->dstAccessMask);
+    size += vn_sizeof_VkFlags(&val->dependencyFlags);
+    size += vn_sizeof_int32_t(&val->viewOffset);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSubpassDependency2(const VkSubpassDependency2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSubpassDependency2_pnext(val->pNext);
+    size += vn_sizeof_VkSubpassDependency2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSubpassDependency2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSubpassDependency2_self(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->srcSubpass);
+    vn_encode_uint32_t(enc, &val->dstSubpass);
+    vn_encode_VkFlags(enc, &val->srcStageMask);
+    vn_encode_VkFlags(enc, &val->dstStageMask);
+    vn_encode_VkFlags(enc, &val->srcAccessMask);
+    vn_encode_VkFlags(enc, &val->dstAccessMask);
+    vn_encode_VkFlags(enc, &val->dependencyFlags);
+    vn_encode_int32_t(enc, &val->viewOffset);
+}
+
+static inline void
+vn_encode_VkSubpassDependency2(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 });
+    vn_encode_VkSubpassDependency2_pnext(enc, val->pNext);
+    vn_encode_VkSubpassDependency2_self(enc, val);
+}
+
+/* struct VkRenderPassCreateInfo2 chain */
+
+static inline size_t
+vn_sizeof_VkRenderPassCreateInfo2_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassCreateInfo2_self(const VkRenderPassCreateInfo2 *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->attachmentCount);
+    if (val->pAttachments) {
+        size += vn_sizeof_array_size(val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            size += vn_sizeof_VkAttachmentDescription2(&val->pAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->subpassCount);
+    if (val->pSubpasses) {
+        size += vn_sizeof_array_size(val->subpassCount);
+        for (uint32_t i = 0; i < val->subpassCount; i++)
+            size += vn_sizeof_VkSubpassDescription2(&val->pSubpasses[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->dependencyCount);
+    if (val->pDependencies) {
+        size += vn_sizeof_array_size(val->dependencyCount);
+        for (uint32_t i = 0; i < val->dependencyCount; i++)
+            size += vn_sizeof_VkSubpassDependency2(&val->pDependencies[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->correlatedViewMaskCount);
+    if (val->pCorrelatedViewMasks) {
+        size += vn_sizeof_array_size(val->correlatedViewMaskCount);
+        size += vn_sizeof_uint32_t_array(val->pCorrelatedViewMasks, val->correlatedViewMaskCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkRenderPassCreateInfo2_pnext(val->pNext);
+    size += vn_sizeof_VkRenderPassCreateInfo2_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkRenderPassCreateInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkRenderPassCreateInfo2_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->attachmentCount);
+    if (val->pAttachments) {
+        vn_encode_array_size(enc, val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            vn_encode_VkAttachmentDescription2(enc, &val->pAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->subpassCount);
+    if (val->pSubpasses) {
+        vn_encode_array_size(enc, val->subpassCount);
+        for (uint32_t i = 0; i < val->subpassCount; i++)
+            vn_encode_VkSubpassDescription2(enc, &val->pSubpasses[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->dependencyCount);
+    if (val->pDependencies) {
+        vn_encode_array_size(enc, val->dependencyCount);
+        for (uint32_t i = 0; i < val->dependencyCount; i++)
+            vn_encode_VkSubpassDependency2(enc, &val->pDependencies[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->correlatedViewMaskCount);
+    if (val->pCorrelatedViewMasks) {
+        vn_encode_array_size(enc, val->correlatedViewMaskCount);
+        vn_encode_uint32_t_array(enc, val->pCorrelatedViewMasks, val->correlatedViewMaskCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkRenderPassCreateInfo2(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 });
+    vn_encode_VkRenderPassCreateInfo2_pnext(enc, val->pNext);
+    vn_encode_VkRenderPassCreateInfo2_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkRenderPassCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
+    if (pRenderPass)
+        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkRenderPassCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pRenderPass))
+        vn_encode_VkRenderPass(enc, pRenderPass);
+}
+
+static inline size_t vn_sizeof_vkCreateRenderPass_reply(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
+    if (pRenderPass)
+        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkRenderPass(dec, pRenderPass);
+    } else {
+        pRenderPass = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkRenderPass(&renderPass);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkRenderPass(enc, &renderPass);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyRenderPass_reply(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip renderPass */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyRenderPass_EXT);
+
+    /* skip device */
+    /* skip renderPass */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkRenderPass(&renderPass);
+    cmd_size += vn_sizeof_simple_pointer(pGranularity);
+    if (pGranularity)
+        cmd_size += vn_sizeof_VkExtent2D_partial(pGranularity);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetRenderAreaGranularity(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkRenderPass(enc, &renderPass);
+    if (vn_encode_simple_pointer(enc, pGranularity))
+        vn_encode_VkExtent2D_partial(enc, pGranularity);
+}
+
+static inline size_t vn_sizeof_vkGetRenderAreaGranularity_reply(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip renderPass */
+    cmd_size += vn_sizeof_simple_pointer(pGranularity);
+    if (pGranularity)
+        cmd_size += vn_sizeof_VkExtent2D(pGranularity);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetRenderAreaGranularity_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT);
+
+    /* skip device */
+    /* skip renderPass */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkExtent2D(dec, pGranularity);
+    } else {
+        pGranularity = NULL;
+    }
+}
+
+static inline size_t vn_sizeof_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkRenderPassCreateInfo2(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
+    if (pRenderPass)
+        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkRenderPassCreateInfo2(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pRenderPass))
+        vn_encode_VkRenderPass(enc, pRenderPass);
+}
+
+static inline size_t vn_sizeof_vkCreateRenderPass2_reply(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
+    if (pRenderPass)
+        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateRenderPass2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass2_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkRenderPass(dec, pRenderPass);
+    } else {
+        pRenderPass = NULL;
+    }
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateRenderPass(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyRenderPass(device, renderPass, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyRenderPass(&submit->command, cmd_flags, device, renderPass, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRenderPass_reply(device, renderPass, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetRenderAreaGranularity(device, renderPass, pGranularity);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetRenderAreaGranularity(&submit->command, cmd_flags, device, renderPass, pGranularity);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetRenderAreaGranularity_reply(device, renderPass, pGranularity) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCreateRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateRenderPass2(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass2_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateRenderPass_reply(&submit.reply, device, pCreateInfo, pAllocator, pRenderPass);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateRenderPass(vn_instance, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit);
+}
+
+static inline void vn_call_vkDestroyRenderPass(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyRenderPass_reply(&submit.reply, device, renderPass, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyRenderPass(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyRenderPass(vn_instance, 0, device, renderPass, pAllocator, &submit);
+}
+
+static inline void vn_call_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetRenderAreaGranularity(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pGranularity, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetRenderAreaGranularity_reply(&submit.reply, device, renderPass, pGranularity);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetRenderAreaGranularity(vn_instance, 0, device, renderPass, pGranularity, &submit);
+}
+
+static inline VkResult vn_call_vkCreateRenderPass2(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateRenderPass2_reply(&submit.reply, device, pCreateInfo, pAllocator, pRenderPass);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateRenderPass2(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateRenderPass2(vn_instance, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_RENDER_PASS_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_sampler.h b/src/virtio/venus-protocol/vn_protocol_driver_sampler.h
new file mode 100644 (file)
index 0000000..f8333d9
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_sampler.h
@@ -0,0 +1,396 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_SAMPLER_H
+#define VN_PROTOCOL_DRIVER_SAMPLER_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkSamplerReductionModeCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSamplerReductionModeCreateInfo_self(const VkSamplerReductionModeCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkSamplerReductionMode(&val->reductionMode);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSamplerReductionModeCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSamplerReductionModeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSamplerReductionModeCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkSamplerReductionMode(enc, &val->reductionMode);
+}
+
+static inline void
+vn_encode_VkSamplerReductionModeCreateInfo(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO });
+    vn_encode_VkSamplerReductionModeCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkSamplerReductionModeCreateInfo_self(enc, val);
+}
+
+/* struct VkSamplerCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkSamplerCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkSamplerYcbcrConversionInfo_self((const VkSamplerYcbcrConversionInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkSamplerReductionModeCreateInfo_self((const VkSamplerReductionModeCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSamplerCreateInfo_self(const VkSamplerCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkFilter(&val->magFilter);
+    size += vn_sizeof_VkFilter(&val->minFilter);
+    size += vn_sizeof_VkSamplerMipmapMode(&val->mipmapMode);
+    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeU);
+    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeV);
+    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeW);
+    size += vn_sizeof_float(&val->mipLodBias);
+    size += vn_sizeof_VkBool32(&val->anisotropyEnable);
+    size += vn_sizeof_float(&val->maxAnisotropy);
+    size += vn_sizeof_VkBool32(&val->compareEnable);
+    size += vn_sizeof_VkCompareOp(&val->compareOp);
+    size += vn_sizeof_float(&val->minLod);
+    size += vn_sizeof_float(&val->maxLod);
+    size += vn_sizeof_VkBorderColor(&val->borderColor);
+    size += vn_sizeof_VkBool32(&val->unnormalizedCoordinates);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSamplerCreateInfo(const VkSamplerCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSamplerCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSamplerCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSamplerCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkSamplerYcbcrConversionInfo_self(enc, (const VkSamplerYcbcrConversionInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkSamplerReductionModeCreateInfo_self(enc, (const VkSamplerReductionModeCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSamplerCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkFilter(enc, &val->magFilter);
+    vn_encode_VkFilter(enc, &val->minFilter);
+    vn_encode_VkSamplerMipmapMode(enc, &val->mipmapMode);
+    vn_encode_VkSamplerAddressMode(enc, &val->addressModeU);
+    vn_encode_VkSamplerAddressMode(enc, &val->addressModeV);
+    vn_encode_VkSamplerAddressMode(enc, &val->addressModeW);
+    vn_encode_float(enc, &val->mipLodBias);
+    vn_encode_VkBool32(enc, &val->anisotropyEnable);
+    vn_encode_float(enc, &val->maxAnisotropy);
+    vn_encode_VkBool32(enc, &val->compareEnable);
+    vn_encode_VkCompareOp(enc, &val->compareOp);
+    vn_encode_float(enc, &val->minLod);
+    vn_encode_float(enc, &val->maxLod);
+    vn_encode_VkBorderColor(enc, &val->borderColor);
+    vn_encode_VkBool32(enc, &val->unnormalizedCoordinates);
+}
+
+static inline void
+vn_encode_VkSamplerCreateInfo(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO });
+    vn_encode_VkSamplerCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkSamplerCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkSamplerCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pSampler);
+    if (pSampler)
+        cmd_size += vn_sizeof_VkSampler(pSampler);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateSampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkSamplerCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pSampler))
+        vn_encode_VkSampler(enc, pSampler);
+}
+
+static inline size_t vn_sizeof_vkCreateSampler_reply(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pSampler);
+    if (pSampler)
+        cmd_size += vn_sizeof_VkSampler(pSampler);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateSampler_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateSampler_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkSampler(dec, pSampler);
+    } else {
+        pSampler = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkSampler(&sampler);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroySampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkSampler(enc, &sampler);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroySampler_reply(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip sampler */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroySampler_reply(struct vn_cs_decoder *dec, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroySampler_EXT);
+
+    /* skip device */
+    /* skip sampler */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateSampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateSampler(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSampler);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSampler_reply(device, pCreateInfo, pAllocator, pSampler) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroySampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroySampler(device, sampler, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroySampler(&submit->command, cmd_flags, device, sampler, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySampler_reply(device, sampler, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSampler, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateSampler_reply(&submit.reply, device, pCreateInfo, pAllocator, pSampler);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSampler(vn_instance, 0, device, pCreateInfo, pAllocator, pSampler, &submit);
+}
+
+static inline void vn_call_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, sampler, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroySampler_reply(&submit.reply, device, sampler, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySampler(vn_instance, 0, device, sampler, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_SAMPLER_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_sampler_ycbcr_conversion.h b/src/virtio/venus-protocol/vn_protocol_driver_sampler_ycbcr_conversion.h
new file mode 100644 (file)
index 0000000..f94adb0
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_sampler_ycbcr_conversion.h
@@ -0,0 +1,282 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_SAMPLER_YCBCR_CONVERSION_H
+#define VN_PROTOCOL_DRIVER_SAMPLER_YCBCR_CONVERSION_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkSamplerYcbcrConversionCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionCreateInfo_self(const VkSamplerYcbcrConversionCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkSamplerYcbcrModelConversion(&val->ycbcrModel);
+    size += vn_sizeof_VkSamplerYcbcrRange(&val->ycbcrRange);
+    size += vn_sizeof_VkComponentMapping(&val->components);
+    size += vn_sizeof_VkChromaLocation(&val->xChromaOffset);
+    size += vn_sizeof_VkChromaLocation(&val->yChromaOffset);
+    size += vn_sizeof_VkFilter(&val->chromaFilter);
+    size += vn_sizeof_VkBool32(&val->forceExplicitReconstruction);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSamplerYcbcrConversionCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSamplerYcbcrConversionCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkSamplerYcbcrModelConversion(enc, &val->ycbcrModel);
+    vn_encode_VkSamplerYcbcrRange(enc, &val->ycbcrRange);
+    vn_encode_VkComponentMapping(enc, &val->components);
+    vn_encode_VkChromaLocation(enc, &val->xChromaOffset);
+    vn_encode_VkChromaLocation(enc, &val->yChromaOffset);
+    vn_encode_VkFilter(enc, &val->chromaFilter);
+    vn_encode_VkBool32(enc, &val->forceExplicitReconstruction);
+}
+
+static inline void
+vn_encode_VkSamplerYcbcrConversionCreateInfo(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO });
+    vn_encode_VkSamplerYcbcrConversionCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkSamplerYcbcrConversionCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pYcbcrConversion);
+    if (pYcbcrConversion)
+        cmd_size += vn_sizeof_VkSamplerYcbcrConversion(pYcbcrConversion);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateSamplerYcbcrConversion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkSamplerYcbcrConversionCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pYcbcrConversion))
+        vn_encode_VkSamplerYcbcrConversion(enc, pYcbcrConversion);
+}
+
+static inline size_t vn_sizeof_vkCreateSamplerYcbcrConversion_reply(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pYcbcrConversion);
+    if (pYcbcrConversion)
+        cmd_size += vn_sizeof_VkSamplerYcbcrConversion(pYcbcrConversion);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateSamplerYcbcrConversion_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkSamplerYcbcrConversion(dec, pYcbcrConversion);
+    } else {
+        pYcbcrConversion = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkSamplerYcbcrConversion(&ycbcrConversion);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroySamplerYcbcrConversion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkSamplerYcbcrConversion(enc, &ycbcrConversion);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroySamplerYcbcrConversion_reply(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip ycbcrConversion */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroySamplerYcbcrConversion_reply(struct vn_cs_decoder *dec, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT);
+
+    /* skip device */
+    /* skip ycbcrConversion */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateSamplerYcbcrConversion(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pYcbcrConversion);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSamplerYcbcrConversion_reply(device, pCreateInfo, pAllocator, pYcbcrConversion) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroySamplerYcbcrConversion(&submit->command, cmd_flags, device, ycbcrConversion, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySamplerYcbcrConversion_reply(device, ycbcrConversion, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSamplerYcbcrConversion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pYcbcrConversion, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateSamplerYcbcrConversion_reply(&submit.reply, device, pCreateInfo, pAllocator, pYcbcrConversion);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSamplerYcbcrConversion(vn_instance, 0, device, pCreateInfo, pAllocator, pYcbcrConversion, &submit);
+}
+
+static inline void vn_call_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySamplerYcbcrConversion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, ycbcrConversion, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroySamplerYcbcrConversion_reply(&submit.reply, device, ycbcrConversion, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySamplerYcbcrConversion(vn_instance, 0, device, ycbcrConversion, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_SAMPLER_YCBCR_CONVERSION_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_semaphore.h b/src/virtio/venus-protocol/vn_protocol_driver_semaphore.h
new file mode 100644 (file)
index 0000000..65e6921
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_semaphore.h
@@ -0,0 +1,820 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_SEMAPHORE_H
+#define VN_PROTOCOL_DRIVER_SEMAPHORE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkExportSemaphoreCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkExportSemaphoreCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExportSemaphoreCreateInfo_self(const VkExportSemaphoreCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->handleTypes);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExportSemaphoreCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkExportSemaphoreCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExportSemaphoreCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExportSemaphoreCreateInfo_self(struct vn_cs_encoder *enc, const VkExportSemaphoreCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->handleTypes);
+}
+
+static inline void
+vn_encode_VkExportSemaphoreCreateInfo(struct vn_cs_encoder *enc, const VkExportSemaphoreCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO });
+    vn_encode_VkExportSemaphoreCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkExportSemaphoreCreateInfo_self(enc, val);
+}
+
+/* struct VkSemaphoreCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkSemaphoreCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSemaphoreCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkExportSemaphoreCreateInfo_self((const VkExportSemaphoreCreateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSemaphoreCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreCreateInfo_self(const VkSemaphoreCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSemaphoreCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSemaphoreCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSemaphoreCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSemaphoreCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkExportSemaphoreCreateInfo_self(enc, (const VkExportSemaphoreCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSemaphoreCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSemaphoreCreateInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+}
+
+static inline void
+vn_encode_VkSemaphoreCreateInfo(struct vn_cs_encoder *enc, const VkSemaphoreCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO });
+    vn_encode_VkSemaphoreCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkSemaphoreCreateInfo_self(enc, val);
+}
+
+/* struct VkSemaphoreWaitInfo chain */
+
+static inline size_t
+vn_sizeof_VkSemaphoreWaitInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreWaitInfo_self(const VkSemaphoreWaitInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->semaphoreCount);
+    if (val->pSemaphores) {
+        size += vn_sizeof_array_size(val->semaphoreCount);
+        for (uint32_t i = 0; i < val->semaphoreCount; i++)
+            size += vn_sizeof_VkSemaphore(&val->pSemaphores[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    if (val->pValues) {
+        size += vn_sizeof_array_size(val->semaphoreCount);
+        size += vn_sizeof_uint64_t_array(val->pValues, val->semaphoreCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSemaphoreWaitInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSemaphoreWaitInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSemaphoreWaitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSemaphoreWaitInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreWaitInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->semaphoreCount);
+    if (val->pSemaphores) {
+        vn_encode_array_size(enc, val->semaphoreCount);
+        for (uint32_t i = 0; i < val->semaphoreCount; i++)
+            vn_encode_VkSemaphore(enc, &val->pSemaphores[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (val->pValues) {
+        vn_encode_array_size(enc, val->semaphoreCount);
+        vn_encode_uint64_t_array(enc, val->pValues, val->semaphoreCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkSemaphoreWaitInfo(struct vn_cs_encoder *enc, const VkSemaphoreWaitInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO });
+    vn_encode_VkSemaphoreWaitInfo_pnext(enc, val->pNext);
+    vn_encode_VkSemaphoreWaitInfo_self(enc, val);
+}
+
+/* struct VkSemaphoreSignalInfo chain */
+
+static inline size_t
+vn_sizeof_VkSemaphoreSignalInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreSignalInfo_self(const VkSemaphoreSignalInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkSemaphore(&val->semaphore);
+    size += vn_sizeof_uint64_t(&val->value);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSemaphoreSignalInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSemaphoreSignalInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSemaphoreSignalInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSemaphoreSignalInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreSignalInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkSemaphore(enc, &val->semaphore);
+    vn_encode_uint64_t(enc, &val->value);
+}
+
+static inline void
+vn_encode_VkSemaphoreSignalInfo(struct vn_cs_encoder *enc, const VkSemaphoreSignalInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO });
+    vn_encode_VkSemaphoreSignalInfo_pnext(enc, val->pNext);
+    vn_encode_VkSemaphoreSignalInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkSemaphoreSignalInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkSemaphoreSignalInfo_self(struct vn_cs_decoder *dec, VkSemaphoreSignalInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkSemaphore(dec, &val->semaphore);
+    vn_decode_uint64_t(dec, &val->value);
+}
+
+static inline void
+vn_decode_VkSemaphoreSignalInfo(struct vn_cs_decoder *dec, VkSemaphoreSignalInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkSemaphoreSignalInfo_pnext(dec, val->pNext);
+    vn_decode_VkSemaphoreSignalInfo_self(dec, val);
+}
+
+static inline size_t vn_sizeof_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkSemaphoreCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pSemaphore);
+    if (pSemaphore)
+        cmd_size += vn_sizeof_VkSemaphore(pSemaphore);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateSemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkSemaphoreCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pSemaphore))
+        vn_encode_VkSemaphore(enc, pSemaphore);
+}
+
+static inline size_t vn_sizeof_vkCreateSemaphore_reply(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pSemaphore);
+    if (pSemaphore)
+        cmd_size += vn_sizeof_VkSemaphore(pSemaphore);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateSemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateSemaphore_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkSemaphore(dec, pSemaphore);
+    } else {
+        pSemaphore = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkSemaphore(&semaphore);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroySemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkSemaphore(enc, &semaphore);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroySemaphore_reply(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip semaphore */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroySemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroySemaphore_EXT);
+
+    /* skip device */
+    /* skip semaphore */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkSemaphore(&semaphore);
+    cmd_size += vn_sizeof_simple_pointer(pValue); /* out */
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetSemaphoreCounterValue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkSemaphore(enc, &semaphore);
+    vn_encode_simple_pointer(enc, pValue); /* out */
+}
+
+static inline size_t vn_sizeof_vkGetSemaphoreCounterValue_reply(VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip semaphore */
+    cmd_size += vn_sizeof_simple_pointer(pValue);
+    if (pValue)
+        cmd_size += vn_sizeof_uint64_t(pValue);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetSemaphoreCounterValue_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip semaphore */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint64_t(dec, pValue);
+    } else {
+        pValue = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pWaitInfo);
+    if (pWaitInfo)
+        cmd_size += vn_sizeof_VkSemaphoreWaitInfo(pWaitInfo);
+    cmd_size += vn_sizeof_uint64_t(&timeout);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkWaitSemaphores(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pWaitInfo))
+        vn_encode_VkSemaphoreWaitInfo(enc, pWaitInfo);
+    vn_encode_uint64_t(enc, &timeout);
+}
+
+static inline size_t vn_sizeof_vkWaitSemaphores_reply(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pWaitInfo */
+    /* skip timeout */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkWaitSemaphores_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkWaitSemaphores_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pWaitInfo */
+    /* skip timeout */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pSignalInfo);
+    if (pSignalInfo)
+        cmd_size += vn_sizeof_VkSemaphoreSignalInfo(pSignalInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkSignalSemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pSignalInfo))
+        vn_encode_VkSemaphoreSignalInfo(enc, pSignalInfo);
+}
+
+static inline size_t vn_sizeof_vkSignalSemaphore_reply(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pSignalInfo */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkSignalSemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkSignalSemaphore_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pSignalInfo */
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateSemaphore(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSemaphore);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSemaphore_reply(device, pCreateInfo, pAllocator, pSemaphore) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroySemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroySemaphore(device, semaphore, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroySemaphore(&submit->command, cmd_flags, device, semaphore, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySemaphore_reply(device, semaphore, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetSemaphoreCounterValue(device, semaphore, pValue);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetSemaphoreCounterValue(&submit->command, cmd_flags, device, semaphore, pValue);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetSemaphoreCounterValue_reply(device, semaphore, pValue) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkWaitSemaphores(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkWaitSemaphores(device, pWaitInfo, timeout);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkWaitSemaphores(&submit->command, cmd_flags, device, pWaitInfo, timeout);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitSemaphores_reply(device, pWaitInfo, timeout) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkSignalSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkSignalSemaphore(device, pSignalInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkSignalSemaphore(&submit->command, cmd_flags, device, pSignalInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSignalSemaphore_reply(device, pSignalInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSemaphore, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateSemaphore_reply(&submit.reply, device, pCreateInfo, pAllocator, pSemaphore);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSemaphore(vn_instance, 0, device, pCreateInfo, pAllocator, pSemaphore, &submit);
+}
+
+static inline void vn_call_vkDestroySemaphore(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroySemaphore_reply(&submit.reply, device, semaphore, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroySemaphore(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySemaphore(vn_instance, 0, device, semaphore, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetSemaphoreCounterValue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pValue, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetSemaphoreCounterValue_reply(&submit.reply, device, semaphore, pValue);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetSemaphoreCounterValue(vn_instance, 0, device, semaphore, pValue, &submit);
+}
+
+static inline VkResult vn_call_vkWaitSemaphores(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWaitSemaphores(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pWaitInfo, timeout, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkWaitSemaphores_reply(&submit.reply, device, pWaitInfo, timeout);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkWaitSemaphores(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWaitSemaphores(vn_instance, 0, device, pWaitInfo, timeout, &submit);
+}
+
+static inline VkResult vn_call_vkSignalSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSignalSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pSignalInfo, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkSignalSemaphore_reply(&submit.reply, device, pSignalInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkSignalSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSignalSemaphore(vn_instance, 0, device, pSignalInfo, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_SEMAPHORE_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_shader_module.h b/src/virtio/venus-protocol/vn_protocol_driver_shader_module.h
new file mode 100644 (file)
index 0000000..2cafb63
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_shader_module.h
@@ -0,0 +1,282 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_SHADER_MODULE_H
+#define VN_PROTOCOL_DRIVER_SHADER_MODULE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkShaderModuleCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkShaderModuleCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkShaderModuleCreateInfo_self(const VkShaderModuleCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_size_t(&val->codeSize);
+    if (val->pCode) {
+        size += vn_sizeof_array_size(val->codeSize / 4);
+        size += vn_sizeof_uint32_t_array(val->pCode, val->codeSize / 4);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkShaderModuleCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkShaderModuleCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkShaderModuleCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkShaderModuleCreateInfo_self(struct vn_cs_encoder *enc, const VkShaderModuleCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_size_t(enc, &val->codeSize);
+    if (val->pCode) {
+        vn_encode_array_size(enc, val->codeSize / 4);
+        vn_encode_uint32_t_array(enc, val->pCode, val->codeSize / 4);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkShaderModuleCreateInfo(struct vn_cs_encoder *enc, const VkShaderModuleCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO });
+    vn_encode_VkShaderModuleCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkShaderModuleCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkShaderModuleCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pShaderModule);
+    if (pShaderModule)
+        cmd_size += vn_sizeof_VkShaderModule(pShaderModule);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateShaderModule(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkShaderModuleCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pShaderModule))
+        vn_encode_VkShaderModule(enc, pShaderModule);
+}
+
+static inline size_t vn_sizeof_vkCreateShaderModule_reply(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pShaderModule);
+    if (pShaderModule)
+        cmd_size += vn_sizeof_VkShaderModule(pShaderModule);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateShaderModule_reply(struct vn_cs_decoder *dec, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateShaderModule_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkShaderModule(dec, pShaderModule);
+    } else {
+        pShaderModule = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkShaderModule(&shaderModule);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyShaderModule(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkShaderModule(enc, &shaderModule);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyShaderModule_reply(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip shaderModule */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyShaderModule_reply(struct vn_cs_decoder *dec, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyShaderModule_EXT);
+
+    /* skip device */
+    /* skip shaderModule */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateShaderModule(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateShaderModule(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pShaderModule);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateShaderModule_reply(device, pCreateInfo, pAllocator, pShaderModule) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyShaderModule(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyShaderModule(device, shaderModule, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyShaderModule(&submit->command, cmd_flags, device, shaderModule, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyShaderModule_reply(device, shaderModule, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateShaderModule(struct vn_instance *vn_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateShaderModule(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pShaderModule, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateShaderModule_reply(&submit.reply, device, pCreateInfo, pAllocator, pShaderModule);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateShaderModule(struct vn_instance *vn_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateShaderModule(vn_instance, 0, device, pCreateInfo, pAllocator, pShaderModule, &submit);
+}
+
+static inline void vn_call_vkDestroyShaderModule(struct vn_instance *vn_instance, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyShaderModule(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, shaderModule, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyShaderModule_reply(&submit.reply, device, shaderModule, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyShaderModule(struct vn_instance *vn_instance, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyShaderModule(vn_instance, 0, device, shaderModule, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_SHADER_MODULE_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_structs.h b/src/virtio/venus-protocol/vn_protocol_driver_structs.h
index 2dfa6b1..78b6e77 100644 (file)
--- a/src/virtio/venus-protocol/vn_protocol_driver_structs.h
+++ b/src/virtio/venus-protocol/vn_protocol_driver_structs.h
@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC
@@ -11,20733 +11,334 @@
 #include "vn_protocol_driver_handles.h"
 
 /*
- * These structs/unions are not included
+ * These structs/unions/commands are not included
  *
- *   VkBaseOutStructure
- *   VkBaseInStructure
  *   VkAllocationCallbacks
  */
 
-/* struct VkOffset2D */
-
-static inline size_t
-vn_sizeof_VkOffset2D(const VkOffset2D *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_int32_t(&val->x);
-    size += vn_sizeof_int32_t(&val->y);
-    return size;
-}
-
-static inline void
-vn_encode_VkOffset2D(struct vn_cs_encoder *enc, const VkOffset2D *val)
-{
-    vn_encode_int32_t(enc, &val->x);
-    vn_encode_int32_t(enc, &val->y);
-}
-
-static inline void
-vn_decode_VkOffset2D(struct vn_cs_decoder *dec, VkOffset2D *val)
-{
-    vn_decode_int32_t(dec, &val->x);
-    vn_decode_int32_t(dec, &val->y);
-}
-
-static inline size_t
-vn_sizeof_VkOffset2D_partial(const VkOffset2D *val)
-{
-    size_t size = 0;
-    /* skip val->x */
-    /* skip val->y */
-    return size;
-}
-
-static inline void
-vn_encode_VkOffset2D_partial(struct vn_cs_encoder *enc, const VkOffset2D *val)
-{
-    /* skip val->x */
-    /* skip val->y */
-}
-
-/* struct VkOffset3D */
-
-static inline size_t
-vn_sizeof_VkOffset3D(const VkOffset3D *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_int32_t(&val->x);
-    size += vn_sizeof_int32_t(&val->y);
-    size += vn_sizeof_int32_t(&val->z);
-    return size;
-}
-
-static inline void
-vn_encode_VkOffset3D(struct vn_cs_encoder *enc, const VkOffset3D *val)
-{
-    vn_encode_int32_t(enc, &val->x);
-    vn_encode_int32_t(enc, &val->y);
-    vn_encode_int32_t(enc, &val->z);
-}
-
-/* struct VkExtent2D */
+/* struct VkExtent3D */
 
 static inline size_t
-vn_sizeof_VkExtent2D(const VkExtent2D *val)
+vn_sizeof_VkExtent3D(const VkExtent3D *val)
 {
     size_t size = 0;
     size += vn_sizeof_uint32_t(&val->width);
     size += vn_sizeof_uint32_t(&val->height);
+    size += vn_sizeof_uint32_t(&val->depth);
     return size;
 }
 
 static inline void
-vn_encode_VkExtent2D(struct vn_cs_encoder *enc, const VkExtent2D *val)
+vn_encode_VkExtent3D(struct vn_cs_encoder *enc, const VkExtent3D *val)
 {
     vn_encode_uint32_t(enc, &val->width);
     vn_encode_uint32_t(enc, &val->height);
+    vn_encode_uint32_t(enc, &val->depth);
 }
 
 static inline void
-vn_decode_VkExtent2D(struct vn_cs_decoder *dec, VkExtent2D *val)
+vn_decode_VkExtent3D(struct vn_cs_decoder *dec, VkExtent3D *val)
 {
     vn_decode_uint32_t(dec, &val->width);
     vn_decode_uint32_t(dec, &val->height);
+    vn_decode_uint32_t(dec, &val->depth);
 }
 
 static inline size_t
-vn_sizeof_VkExtent2D_partial(const VkExtent2D *val)
+vn_sizeof_VkExtent3D_partial(const VkExtent3D *val)
 {
     size_t size = 0;
     /* skip val->width */
     /* skip val->height */
+    /* skip val->depth */
     return size;
 }
 
 static inline void
-vn_encode_VkExtent2D_partial(struct vn_cs_encoder *enc, const VkExtent2D *val)
+vn_encode_VkExtent3D_partial(struct vn_cs_encoder *enc, const VkExtent3D *val)
 {
     /* skip val->width */
     /* skip val->height */
+    /* skip val->depth */
 }
 
-/* struct VkExtent3D */
+/* struct VkLayerProperties */
 
 static inline size_t
-vn_sizeof_VkExtent3D(const VkExtent3D *val)
+vn_sizeof_VkLayerProperties(const VkLayerProperties *val)
 {
     size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->width);
-    size += vn_sizeof_uint32_t(&val->height);
-    size += vn_sizeof_uint32_t(&val->depth);
+    size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
+    size += vn_sizeof_blob_array(val->layerName, VK_MAX_EXTENSION_NAME_SIZE);
+    size += vn_sizeof_uint32_t(&val->specVersion);
+    size += vn_sizeof_uint32_t(&val->implementationVersion);
+    size += vn_sizeof_array_size(VK_MAX_DESCRIPTION_SIZE);
+    size += vn_sizeof_blob_array(val->description, VK_MAX_DESCRIPTION_SIZE);
     return size;
 }
 
 static inline void
-vn_encode_VkExtent3D(struct vn_cs_encoder *enc, const VkExtent3D *val)
-{
-    vn_encode_uint32_t(enc, &val->width);
-    vn_encode_uint32_t(enc, &val->height);
-    vn_encode_uint32_t(enc, &val->depth);
-}
-
-static inline void
-vn_decode_VkExtent3D(struct vn_cs_decoder *dec, VkExtent3D *val)
+vn_decode_VkLayerProperties(struct vn_cs_decoder *dec, VkLayerProperties *val)
 {
-    vn_decode_uint32_t(dec, &val->width);
-    vn_decode_uint32_t(dec, &val->height);
-    vn_decode_uint32_t(dec, &val->depth);
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
+        vn_decode_blob_array(dec, val->layerName, array_size);
+    }
+    vn_decode_uint32_t(dec, &val->specVersion);
+    vn_decode_uint32_t(dec, &val->implementationVersion);
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_MAX_DESCRIPTION_SIZE);
+        vn_decode_blob_array(dec, val->description, array_size);
+    }
 }
 
 static inline size_t
-vn_sizeof_VkExtent3D_partial(const VkExtent3D *val)
+vn_sizeof_VkLayerProperties_partial(const VkLayerProperties *val)
 {
     size_t size = 0;
-    /* skip val->width */
-    /* skip val->height */
-    /* skip val->depth */
+    /* skip val->layerName */
+    /* skip val->specVersion */
+    /* skip val->implementationVersion */
+    /* skip val->description */
     return size;
 }
 
 static inline void
-vn_encode_VkExtent3D_partial(struct vn_cs_encoder *enc, const VkExtent3D *val)
+vn_encode_VkLayerProperties_partial(struct vn_cs_encoder *enc, const VkLayerProperties *val)
 {
-    /* skip val->width */
-    /* skip val->height */
-    /* skip val->depth */
+    /* skip val->layerName */
+    /* skip val->specVersion */
+    /* skip val->implementationVersion */
+    /* skip val->description */
 }
 
-/* struct VkViewport */
+/* struct VkExtensionProperties */
 
 static inline size_t
-vn_sizeof_VkViewport(const VkViewport *val)
+vn_sizeof_VkExtensionProperties(const VkExtensionProperties *val)
 {
     size_t size = 0;
-    size += vn_sizeof_float(&val->x);
-    size += vn_sizeof_float(&val->y);
-    size += vn_sizeof_float(&val->width);
-    size += vn_sizeof_float(&val->height);
-    size += vn_sizeof_float(&val->minDepth);
-    size += vn_sizeof_float(&val->maxDepth);
+    size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
+    size += vn_sizeof_blob_array(val->extensionName, VK_MAX_EXTENSION_NAME_SIZE);
+    size += vn_sizeof_uint32_t(&val->specVersion);
     return size;
 }
 
 static inline void
-vn_encode_VkViewport(struct vn_cs_encoder *enc, const VkViewport *val)
+vn_decode_VkExtensionProperties(struct vn_cs_decoder *dec, VkExtensionProperties *val)
 {
-    vn_encode_float(enc, &val->x);
-    vn_encode_float(enc, &val->y);
-    vn_encode_float(enc, &val->width);
-    vn_encode_float(enc, &val->height);
-    vn_encode_float(enc, &val->minDepth);
-    vn_encode_float(enc, &val->maxDepth);
+    {
+        const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
+        vn_decode_blob_array(dec, val->extensionName, array_size);
+    }
+    vn_decode_uint32_t(dec, &val->specVersion);
 }
 
-/* struct VkRect2D */
-
 static inline size_t
-vn_sizeof_VkRect2D(const VkRect2D *val)
+vn_sizeof_VkExtensionProperties_partial(const VkExtensionProperties *val)
 {
     size_t size = 0;
-    size += vn_sizeof_VkOffset2D(&val->offset);
-    size += vn_sizeof_VkExtent2D(&val->extent);
+    /* skip val->extensionName */
+    /* skip val->specVersion */
     return size;
 }
 
 static inline void
-vn_encode_VkRect2D(struct vn_cs_encoder *enc, const VkRect2D *val)
+vn_encode_VkExtensionProperties_partial(struct vn_cs_encoder *enc, const VkExtensionProperties *val)
 {
-    vn_encode_VkOffset2D(enc, &val->offset);
-    vn_encode_VkExtent2D(enc, &val->extent);
+    /* skip val->extensionName */
+    /* skip val->specVersion */
 }
 
-static inline void
-vn_decode_VkRect2D(struct vn_cs_decoder *dec, VkRect2D *val)
-{
-    vn_decode_VkOffset2D(dec, &val->offset);
-    vn_decode_VkExtent2D(dec, &val->extent);
-}
+/* struct VkMemoryRequirements */
 
 static inline size_t
-vn_sizeof_VkRect2D_partial(const VkRect2D *val)
+vn_sizeof_VkMemoryRequirements(const VkMemoryRequirements *val)
 {
     size_t size = 0;
-    size += vn_sizeof_VkOffset2D_partial(&val->offset);
-    size += vn_sizeof_VkExtent2D_partial(&val->extent);
+    size += vn_sizeof_VkDeviceSize(&val->size);
+    size += vn_sizeof_VkDeviceSize(&val->alignment);
+    size += vn_sizeof_uint32_t(&val->memoryTypeBits);
     return size;
 }
 
 static inline void
-vn_encode_VkRect2D_partial(struct vn_cs_encoder *enc, const VkRect2D *val)
+vn_decode_VkMemoryRequirements(struct vn_cs_decoder *dec, VkMemoryRequirements *val)
 {
-    vn_encode_VkOffset2D_partial(enc, &val->offset);
-    vn_encode_VkExtent2D_partial(enc, &val->extent);
+    vn_decode_VkDeviceSize(dec, &val->size);
+    vn_decode_VkDeviceSize(dec, &val->alignment);
+    vn_decode_uint32_t(dec, &val->memoryTypeBits);
 }
 
-/* struct VkClearRect */
-
 static inline size_t
-vn_sizeof_VkClearRect(const VkClearRect *val)
+vn_sizeof_VkMemoryRequirements_partial(const VkMemoryRequirements *val)
 {
     size_t size = 0;
-    size += vn_sizeof_VkRect2D(&val->rect);
-    size += vn_sizeof_uint32_t(&val->baseArrayLayer);
-    size += vn_sizeof_uint32_t(&val->layerCount);
+    /* skip val->size */
+    /* skip val->alignment */
+    /* skip val->memoryTypeBits */
     return size;
 }
 
 static inline void
-vn_encode_VkClearRect(struct vn_cs_encoder *enc, const VkClearRect *val)
+vn_encode_VkMemoryRequirements_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements *val)
 {
-    vn_encode_VkRect2D(enc, &val->rect);
-    vn_encode_uint32_t(enc, &val->baseArrayLayer);
-    vn_encode_uint32_t(enc, &val->layerCount);
+    /* skip val->size */
+    /* skip val->alignment */
+    /* skip val->memoryTypeBits */
 }
 
-/* struct VkComponentMapping */
+/* struct VkSparseImageFormatProperties */
 
 static inline size_t
-vn_sizeof_VkComponentMapping(const VkComponentMapping *val)
+vn_sizeof_VkSparseImageFormatProperties(const VkSparseImageFormatProperties *val)
 {
     size_t size = 0;
-    size += vn_sizeof_VkComponentSwizzle(&val->r);
-    size += vn_sizeof_VkComponentSwizzle(&val->g);
-    size += vn_sizeof_VkComponentSwizzle(&val->b);
-    size += vn_sizeof_VkComponentSwizzle(&val->a);
+    size += vn_sizeof_VkFlags(&val->aspectMask);
+    size += vn_sizeof_VkExtent3D(&val->imageGranularity);
+    size += vn_sizeof_VkFlags(&val->flags);
     return size;
 }
 
 static inline void
-vn_encode_VkComponentMapping(struct vn_cs_encoder *enc, const VkComponentMapping *val)
-{
-    vn_encode_VkComponentSwizzle(enc, &val->r);
-    vn_encode_VkComponentSwizzle(enc, &val->g);
-    vn_encode_VkComponentSwizzle(enc, &val->b);
-    vn_encode_VkComponentSwizzle(enc, &val->a);
-}
-
-static inline void
-vn_decode_VkComponentMapping(struct vn_cs_decoder *dec, VkComponentMapping *val)
+vn_decode_VkSparseImageFormatProperties(struct vn_cs_decoder *dec, VkSparseImageFormatProperties *val)
 {
-    vn_decode_VkComponentSwizzle(dec, &val->r);
-    vn_decode_VkComponentSwizzle(dec, &val->g);
-    vn_decode_VkComponentSwizzle(dec, &val->b);
-    vn_decode_VkComponentSwizzle(dec, &val->a);
+    vn_decode_VkFlags(dec, &val->aspectMask);
+    vn_decode_VkExtent3D(dec, &val->imageGranularity);
+    vn_decode_VkFlags(dec, &val->flags);
 }
 
 static inline size_t
-vn_sizeof_VkComponentMapping_partial(const VkComponentMapping *val)
+vn_sizeof_VkSparseImageFormatProperties_partial(const VkSparseImageFormatProperties *val)
 {
     size_t size = 0;
-    /* skip val->r */
-    /* skip val->g */
-    /* skip val->b */
-    /* skip val->a */
+    /* skip val->aspectMask */
+    size += vn_sizeof_VkExtent3D_partial(&val->imageGranularity);
+    /* skip val->flags */
     return size;
 }
 
 static inline void
-vn_encode_VkComponentMapping_partial(struct vn_cs_encoder *enc, const VkComponentMapping *val)
+vn_encode_VkSparseImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties *val)
 {
-    /* skip val->r */
-    /* skip val->g */
-    /* skip val->b */
-    /* skip val->a */
+    /* skip val->aspectMask */
+    vn_encode_VkExtent3D_partial(enc, &val->imageGranularity);
+    /* skip val->flags */
 }
 
-/* struct VkPhysicalDeviceLimits */
+/* struct VkImageSubresource */
 
 static inline size_t
-vn_sizeof_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits *val)
+vn_sizeof_VkImageSubresource(const VkImageSubresource *val)
 {
     size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->maxImageDimension1D);
-    size += vn_sizeof_uint32_t(&val->maxImageDimension2D);
-    size += vn_sizeof_uint32_t(&val->maxImageDimension3D);
-    size += vn_sizeof_uint32_t(&val->maxImageDimensionCube);
-    size += vn_sizeof_uint32_t(&val->maxImageArrayLayers);
-    size += vn_sizeof_uint32_t(&val->maxTexelBufferElements);
-    size += vn_sizeof_uint32_t(&val->maxUniformBufferRange);
-    size += vn_sizeof_uint32_t(&val->maxStorageBufferRange);
-    size += vn_sizeof_uint32_t(&val->maxPushConstantsSize);
-    size += vn_sizeof_uint32_t(&val->maxMemoryAllocationCount);
-    size += vn_sizeof_uint32_t(&val->maxSamplerAllocationCount);
-    size += vn_sizeof_VkDeviceSize(&val->bufferImageGranularity);
-    size += vn_sizeof_VkDeviceSize(&val->sparseAddressSpaceSize);
-    size += vn_sizeof_uint32_t(&val->maxBoundDescriptorSets);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorSamplers);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUniformBuffers);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorStorageBuffers);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorSampledImages);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorStorageImages);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInputAttachments);
-    size += vn_sizeof_uint32_t(&val->maxPerStageResources);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetSamplers);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUniformBuffers);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUniformBuffersDynamic);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageBuffers);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageBuffersDynamic);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetSampledImages);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageImages);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetInputAttachments);
-    size += vn_sizeof_uint32_t(&val->maxVertexInputAttributes);
-    size += vn_sizeof_uint32_t(&val->maxVertexInputBindings);
-    size += vn_sizeof_uint32_t(&val->maxVertexInputAttributeOffset);
-    size += vn_sizeof_uint32_t(&val->maxVertexInputBindingStride);
-    size += vn_sizeof_uint32_t(&val->maxVertexOutputComponents);
-    size += vn_sizeof_uint32_t(&val->maxTessellationGenerationLevel);
-    size += vn_sizeof_uint32_t(&val->maxTessellationPatchSize);
-    size += vn_sizeof_uint32_t(&val->maxTessellationControlPerVertexInputComponents);
-    size += vn_sizeof_uint32_t(&val->maxTessellationControlPerVertexOutputComponents);
-    size += vn_sizeof_uint32_t(&val->maxTessellationControlPerPatchOutputComponents);
-    size += vn_sizeof_uint32_t(&val->maxTessellationControlTotalOutputComponents);
-    size += vn_sizeof_uint32_t(&val->maxTessellationEvaluationInputComponents);
-    size += vn_sizeof_uint32_t(&val->maxTessellationEvaluationOutputComponents);
-    size += vn_sizeof_uint32_t(&val->maxGeometryShaderInvocations);
-    size += vn_sizeof_uint32_t(&val->maxGeometryInputComponents);
-    size += vn_sizeof_uint32_t(&val->maxGeometryOutputComponents);
-    size += vn_sizeof_uint32_t(&val->maxGeometryOutputVertices);
-    size += vn_sizeof_uint32_t(&val->maxGeometryTotalOutputComponents);
-    size += vn_sizeof_uint32_t(&val->maxFragmentInputComponents);
-    size += vn_sizeof_uint32_t(&val->maxFragmentOutputAttachments);
-    size += vn_sizeof_uint32_t(&val->maxFragmentDualSrcAttachments);
-    size += vn_sizeof_uint32_t(&val->maxFragmentCombinedOutputResources);
-    size += vn_sizeof_uint32_t(&val->maxComputeSharedMemorySize);
-    size += vn_sizeof_array_size(3);
-    size += vn_sizeof_uint32_t_array(val->maxComputeWorkGroupCount, 3);
-    size += vn_sizeof_uint32_t(&val->maxComputeWorkGroupInvocations);
-    size += vn_sizeof_array_size(3);
-    size += vn_sizeof_uint32_t_array(val->maxComputeWorkGroupSize, 3);
-    size += vn_sizeof_uint32_t(&val->subPixelPrecisionBits);
-    size += vn_sizeof_uint32_t(&val->subTexelPrecisionBits);
-    size += vn_sizeof_uint32_t(&val->mipmapPrecisionBits);
-    size += vn_sizeof_uint32_t(&val->maxDrawIndexedIndexValue);
-    size += vn_sizeof_uint32_t(&val->maxDrawIndirectCount);
-    size += vn_sizeof_float(&val->maxSamplerLodBias);
-    size += vn_sizeof_float(&val->maxSamplerAnisotropy);
-    size += vn_sizeof_uint32_t(&val->maxViewports);
-    size += vn_sizeof_array_size(2);
-    size += vn_sizeof_uint32_t_array(val->maxViewportDimensions, 2);
-    size += vn_sizeof_array_size(2);
-    size += vn_sizeof_float_array(val->viewportBoundsRange, 2);
-    size += vn_sizeof_uint32_t(&val->viewportSubPixelBits);
-    size += vn_sizeof_size_t(&val->minMemoryMapAlignment);
-    size += vn_sizeof_VkDeviceSize(&val->minTexelBufferOffsetAlignment);
-    size += vn_sizeof_VkDeviceSize(&val->minUniformBufferOffsetAlignment);
-    size += vn_sizeof_VkDeviceSize(&val->minStorageBufferOffsetAlignment);
-    size += vn_sizeof_int32_t(&val->minTexelOffset);
-    size += vn_sizeof_uint32_t(&val->maxTexelOffset);
-    size += vn_sizeof_int32_t(&val->minTexelGatherOffset);
-    size += vn_sizeof_uint32_t(&val->maxTexelGatherOffset);
-    size += vn_sizeof_float(&val->minInterpolationOffset);
-    size += vn_sizeof_float(&val->maxInterpolationOffset);
-    size += vn_sizeof_uint32_t(&val->subPixelInterpolationOffsetBits);
-    size += vn_sizeof_uint32_t(&val->maxFramebufferWidth);
-    size += vn_sizeof_uint32_t(&val->maxFramebufferHeight);
-    size += vn_sizeof_uint32_t(&val->maxFramebufferLayers);
-    size += vn_sizeof_VkFlags(&val->framebufferColorSampleCounts);
-    size += vn_sizeof_VkFlags(&val->framebufferDepthSampleCounts);
-    size += vn_sizeof_VkFlags(&val->framebufferStencilSampleCounts);
-    size += vn_sizeof_VkFlags(&val->framebufferNoAttachmentsSampleCounts);
-    size += vn_sizeof_uint32_t(&val->maxColorAttachments);
-    size += vn_sizeof_VkFlags(&val->sampledImageColorSampleCounts);
-    size += vn_sizeof_VkFlags(&val->sampledImageIntegerSampleCounts);
-    size += vn_sizeof_VkFlags(&val->sampledImageDepthSampleCounts);
-    size += vn_sizeof_VkFlags(&val->sampledImageStencilSampleCounts);
-    size += vn_sizeof_VkFlags(&val->storageImageSampleCounts);
-    size += vn_sizeof_uint32_t(&val->maxSampleMaskWords);
-    size += vn_sizeof_VkBool32(&val->timestampComputeAndGraphics);
-    size += vn_sizeof_float(&val->timestampPeriod);
-    size += vn_sizeof_uint32_t(&val->maxClipDistances);
-    size += vn_sizeof_uint32_t(&val->maxCullDistances);
-    size += vn_sizeof_uint32_t(&val->maxCombinedClipAndCullDistances);
-    size += vn_sizeof_uint32_t(&val->discreteQueuePriorities);
-    size += vn_sizeof_array_size(2);
-    size += vn_sizeof_float_array(val->pointSizeRange, 2);
-    size += vn_sizeof_array_size(2);
-    size += vn_sizeof_float_array(val->lineWidthRange, 2);
-    size += vn_sizeof_float(&val->pointSizeGranularity);
-    size += vn_sizeof_float(&val->lineWidthGranularity);
-    size += vn_sizeof_VkBool32(&val->strictLines);
-    size += vn_sizeof_VkBool32(&val->standardSampleLocations);
-    size += vn_sizeof_VkDeviceSize(&val->optimalBufferCopyOffsetAlignment);
-    size += vn_sizeof_VkDeviceSize(&val->optimalBufferCopyRowPitchAlignment);
-    size += vn_sizeof_VkDeviceSize(&val->nonCoherentAtomSize);
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceLimits(struct vn_cs_decoder *dec, VkPhysicalDeviceLimits *val)
-{
-    vn_decode_uint32_t(dec, &val->maxImageDimension1D);
-    vn_decode_uint32_t(dec, &val->maxImageDimension2D);
-    vn_decode_uint32_t(dec, &val->maxImageDimension3D);
-    vn_decode_uint32_t(dec, &val->maxImageDimensionCube);
-    vn_decode_uint32_t(dec, &val->maxImageArrayLayers);
-    vn_decode_uint32_t(dec, &val->maxTexelBufferElements);
-    vn_decode_uint32_t(dec, &val->maxUniformBufferRange);
-    vn_decode_uint32_t(dec, &val->maxStorageBufferRange);
-    vn_decode_uint32_t(dec, &val->maxPushConstantsSize);
-    vn_decode_uint32_t(dec, &val->maxMemoryAllocationCount);
-    vn_decode_uint32_t(dec, &val->maxSamplerAllocationCount);
-    vn_decode_VkDeviceSize(dec, &val->bufferImageGranularity);
-    vn_decode_VkDeviceSize(dec, &val->sparseAddressSpaceSize);
-    vn_decode_uint32_t(dec, &val->maxBoundDescriptorSets);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorSamplers);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUniformBuffers);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorStorageBuffers);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorSampledImages);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorStorageImages);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInputAttachments);
-    vn_decode_uint32_t(dec, &val->maxPerStageResources);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetSamplers);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUniformBuffers);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUniformBuffersDynamic);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageBuffers);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageBuffersDynamic);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetSampledImages);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageImages);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetInputAttachments);
-    vn_decode_uint32_t(dec, &val->maxVertexInputAttributes);
-    vn_decode_uint32_t(dec, &val->maxVertexInputBindings);
-    vn_decode_uint32_t(dec, &val->maxVertexInputAttributeOffset);
-    vn_decode_uint32_t(dec, &val->maxVertexInputBindingStride);
-    vn_decode_uint32_t(dec, &val->maxVertexOutputComponents);
-    vn_decode_uint32_t(dec, &val->maxTessellationGenerationLevel);
-    vn_decode_uint32_t(dec, &val->maxTessellationPatchSize);
-    vn_decode_uint32_t(dec, &val->maxTessellationControlPerVertexInputComponents);
-    vn_decode_uint32_t(dec, &val->maxTessellationControlPerVertexOutputComponents);
-    vn_decode_uint32_t(dec, &val->maxTessellationControlPerPatchOutputComponents);
-    vn_decode_uint32_t(dec, &val->maxTessellationControlTotalOutputComponents);
-    vn_decode_uint32_t(dec, &val->maxTessellationEvaluationInputComponents);
-    vn_decode_uint32_t(dec, &val->maxTessellationEvaluationOutputComponents);
-    vn_decode_uint32_t(dec, &val->maxGeometryShaderInvocations);
-    vn_decode_uint32_t(dec, &val->maxGeometryInputComponents);
-    vn_decode_uint32_t(dec, &val->maxGeometryOutputComponents);
-    vn_decode_uint32_t(dec, &val->maxGeometryOutputVertices);
-    vn_decode_uint32_t(dec, &val->maxGeometryTotalOutputComponents);
-    vn_decode_uint32_t(dec, &val->maxFragmentInputComponents);
-    vn_decode_uint32_t(dec, &val->maxFragmentOutputAttachments);
-    vn_decode_uint32_t(dec, &val->maxFragmentDualSrcAttachments);
-    vn_decode_uint32_t(dec, &val->maxFragmentCombinedOutputResources);
-    vn_decode_uint32_t(dec, &val->maxComputeSharedMemorySize);
-    {
-        const size_t array_size = vn_decode_array_size(dec, 3);
-        vn_decode_uint32_t_array(dec, val->maxComputeWorkGroupCount, array_size);
-    }
-    vn_decode_uint32_t(dec, &val->maxComputeWorkGroupInvocations);
-    {
-        const size_t array_size = vn_decode_array_size(dec, 3);
-        vn_decode_uint32_t_array(dec, val->maxComputeWorkGroupSize, array_size);
-    }
-    vn_decode_uint32_t(dec, &val->subPixelPrecisionBits);
-    vn_decode_uint32_t(dec, &val->subTexelPrecisionBits);
-    vn_decode_uint32_t(dec, &val->mipmapPrecisionBits);
-    vn_decode_uint32_t(dec, &val->maxDrawIndexedIndexValue);
-    vn_decode_uint32_t(dec, &val->maxDrawIndirectCount);
-    vn_decode_float(dec, &val->maxSamplerLodBias);
-    vn_decode_float(dec, &val->maxSamplerAnisotropy);
-    vn_decode_uint32_t(dec, &val->maxViewports);
-    {
-        const size_t array_size = vn_decode_array_size(dec, 2);
-        vn_decode_uint32_t_array(dec, val->maxViewportDimensions, array_size);
-    }
-    {
-        const size_t array_size = vn_decode_array_size(dec, 2);
-        vn_decode_float_array(dec, val->viewportBoundsRange, array_size);
-    }
-    vn_decode_uint32_t(dec, &val->viewportSubPixelBits);
-    vn_decode_size_t(dec, &val->minMemoryMapAlignment);
-    vn_decode_VkDeviceSize(dec, &val->minTexelBufferOffsetAlignment);
-    vn_decode_VkDeviceSize(dec, &val->minUniformBufferOffsetAlignment);
-    vn_decode_VkDeviceSize(dec, &val->minStorageBufferOffsetAlignment);
-    vn_decode_int32_t(dec, &val->minTexelOffset);
-    vn_decode_uint32_t(dec, &val->maxTexelOffset);
-    vn_decode_int32_t(dec, &val->minTexelGatherOffset);
-    vn_decode_uint32_t(dec, &val->maxTexelGatherOffset);
-    vn_decode_float(dec, &val->minInterpolationOffset);
-    vn_decode_float(dec, &val->maxInterpolationOffset);
-    vn_decode_uint32_t(dec, &val->subPixelInterpolationOffsetBits);
-    vn_decode_uint32_t(dec, &val->maxFramebufferWidth);
-    vn_decode_uint32_t(dec, &val->maxFramebufferHeight);
-    vn_decode_uint32_t(dec, &val->maxFramebufferLayers);
-    vn_decode_VkFlags(dec, &val->framebufferColorSampleCounts);
-    vn_decode_VkFlags(dec, &val->framebufferDepthSampleCounts);
-    vn_decode_VkFlags(dec, &val->framebufferStencilSampleCounts);
-    vn_decode_VkFlags(dec, &val->framebufferNoAttachmentsSampleCounts);
-    vn_decode_uint32_t(dec, &val->maxColorAttachments);
-    vn_decode_VkFlags(dec, &val->sampledImageColorSampleCounts);
-    vn_decode_VkFlags(dec, &val->sampledImageIntegerSampleCounts);
-    vn_decode_VkFlags(dec, &val->sampledImageDepthSampleCounts);
-    vn_decode_VkFlags(dec, &val->sampledImageStencilSampleCounts);
-    vn_decode_VkFlags(dec, &val->storageImageSampleCounts);
-    vn_decode_uint32_t(dec, &val->maxSampleMaskWords);
-    vn_decode_VkBool32(dec, &val->timestampComputeAndGraphics);
-    vn_decode_float(dec, &val->timestampPeriod);
-    vn_decode_uint32_t(dec, &val->maxClipDistances);
-    vn_decode_uint32_t(dec, &val->maxCullDistances);
-    vn_decode_uint32_t(dec, &val->maxCombinedClipAndCullDistances);
-    vn_decode_uint32_t(dec, &val->discreteQueuePriorities);
-    {
-        const size_t array_size = vn_decode_array_size(dec, 2);
-        vn_decode_float_array(dec, val->pointSizeRange, array_size);
-    }
-    {
-        const size_t array_size = vn_decode_array_size(dec, 2);
-        vn_decode_float_array(dec, val->lineWidthRange, array_size);
-    }
-    vn_decode_float(dec, &val->pointSizeGranularity);
-    vn_decode_float(dec, &val->lineWidthGranularity);
-    vn_decode_VkBool32(dec, &val->strictLines);
-    vn_decode_VkBool32(dec, &val->standardSampleLocations);
-    vn_decode_VkDeviceSize(dec, &val->optimalBufferCopyOffsetAlignment);
-    vn_decode_VkDeviceSize(dec, &val->optimalBufferCopyRowPitchAlignment);
-    vn_decode_VkDeviceSize(dec, &val->nonCoherentAtomSize);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceLimits_partial(const VkPhysicalDeviceLimits *val)
-{
-    size_t size = 0;
-    /* skip val->maxImageDimension1D */
-    /* skip val->maxImageDimension2D */
-    /* skip val->maxImageDimension3D */
-    /* skip val->maxImageDimensionCube */
-    /* skip val->maxImageArrayLayers */
-    /* skip val->maxTexelBufferElements */
-    /* skip val->maxUniformBufferRange */
-    /* skip val->maxStorageBufferRange */
-    /* skip val->maxPushConstantsSize */
-    /* skip val->maxMemoryAllocationCount */
-    /* skip val->maxSamplerAllocationCount */
-    /* skip val->bufferImageGranularity */
-    /* skip val->sparseAddressSpaceSize */
-    /* skip val->maxBoundDescriptorSets */
-    /* skip val->maxPerStageDescriptorSamplers */
-    /* skip val->maxPerStageDescriptorUniformBuffers */
-    /* skip val->maxPerStageDescriptorStorageBuffers */
-    /* skip val->maxPerStageDescriptorSampledImages */
-    /* skip val->maxPerStageDescriptorStorageImages */
-    /* skip val->maxPerStageDescriptorInputAttachments */
-    /* skip val->maxPerStageResources */
-    /* skip val->maxDescriptorSetSamplers */
-    /* skip val->maxDescriptorSetUniformBuffers */
-    /* skip val->maxDescriptorSetUniformBuffersDynamic */
-    /* skip val->maxDescriptorSetStorageBuffers */
-    /* skip val->maxDescriptorSetStorageBuffersDynamic */
-    /* skip val->maxDescriptorSetSampledImages */
-    /* skip val->maxDescriptorSetStorageImages */
-    /* skip val->maxDescriptorSetInputAttachments */
-    /* skip val->maxVertexInputAttributes */
-    /* skip val->maxVertexInputBindings */
-    /* skip val->maxVertexInputAttributeOffset */
-    /* skip val->maxVertexInputBindingStride */
-    /* skip val->maxVertexOutputComponents */
-    /* skip val->maxTessellationGenerationLevel */
-    /* skip val->maxTessellationPatchSize */
-    /* skip val->maxTessellationControlPerVertexInputComponents */
-    /* skip val->maxTessellationControlPerVertexOutputComponents */
-    /* skip val->maxTessellationControlPerPatchOutputComponents */
-    /* skip val->maxTessellationControlTotalOutputComponents */
-    /* skip val->maxTessellationEvaluationInputComponents */
-    /* skip val->maxTessellationEvaluationOutputComponents */
-    /* skip val->maxGeometryShaderInvocations */
-    /* skip val->maxGeometryInputComponents */
-    /* skip val->maxGeometryOutputComponents */
-    /* skip val->maxGeometryOutputVertices */
-    /* skip val->maxGeometryTotalOutputComponents */
-    /* skip val->maxFragmentInputComponents */
-    /* skip val->maxFragmentOutputAttachments */
-    /* skip val->maxFragmentDualSrcAttachments */
-    /* skip val->maxFragmentCombinedOutputResources */
-    /* skip val->maxComputeSharedMemorySize */
-    /* skip val->maxComputeWorkGroupCount */
-    /* skip val->maxComputeWorkGroupInvocations */
-    /* skip val->maxComputeWorkGroupSize */
-    /* skip val->subPixelPrecisionBits */
-    /* skip val->subTexelPrecisionBits */
-    /* skip val->mipmapPrecisionBits */
-    /* skip val->maxDrawIndexedIndexValue */
-    /* skip val->maxDrawIndirectCount */
-    /* skip val->maxSamplerLodBias */
-    /* skip val->maxSamplerAnisotropy */
-    /* skip val->maxViewports */
-    /* skip val->maxViewportDimensions */
-    /* skip val->viewportBoundsRange */
-    /* skip val->viewportSubPixelBits */
-    /* skip val->minMemoryMapAlignment */
-    /* skip val->minTexelBufferOffsetAlignment */
-    /* skip val->minUniformBufferOffsetAlignment */
-    /* skip val->minStorageBufferOffsetAlignment */
-    /* skip val->minTexelOffset */
-    /* skip val->maxTexelOffset */
-    /* skip val->minTexelGatherOffset */
-    /* skip val->maxTexelGatherOffset */
-    /* skip val->minInterpolationOffset */
-    /* skip val->maxInterpolationOffset */
-    /* skip val->subPixelInterpolationOffsetBits */
-    /* skip val->maxFramebufferWidth */
-    /* skip val->maxFramebufferHeight */
-    /* skip val->maxFramebufferLayers */
-    /* skip val->framebufferColorSampleCounts */
-    /* skip val->framebufferDepthSampleCounts */
-    /* skip val->framebufferStencilSampleCounts */
-    /* skip val->framebufferNoAttachmentsSampleCounts */
-    /* skip val->maxColorAttachments */
-    /* skip val->sampledImageColorSampleCounts */
-    /* skip val->sampledImageIntegerSampleCounts */
-    /* skip val->sampledImageDepthSampleCounts */
-    /* skip val->sampledImageStencilSampleCounts */
-    /* skip val->storageImageSampleCounts */
-    /* skip val->maxSampleMaskWords */
-    /* skip val->timestampComputeAndGraphics */
-    /* skip val->timestampPeriod */
-    /* skip val->maxClipDistances */
-    /* skip val->maxCullDistances */
-    /* skip val->maxCombinedClipAndCullDistances */
-    /* skip val->discreteQueuePriorities */
-    /* skip val->pointSizeRange */
-    /* skip val->lineWidthRange */
-    /* skip val->pointSizeGranularity */
-    /* skip val->lineWidthGranularity */
-    /* skip val->strictLines */
-    /* skip val->standardSampleLocations */
-    /* skip val->optimalBufferCopyOffsetAlignment */
-    /* skip val->optimalBufferCopyRowPitchAlignment */
-    /* skip val->nonCoherentAtomSize */
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceLimits_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLimits *val)
-{
-    /* skip val->maxImageDimension1D */
-    /* skip val->maxImageDimension2D */
-    /* skip val->maxImageDimension3D */
-    /* skip val->maxImageDimensionCube */
-    /* skip val->maxImageArrayLayers */
-    /* skip val->maxTexelBufferElements */
-    /* skip val->maxUniformBufferRange */
-    /* skip val->maxStorageBufferRange */
-    /* skip val->maxPushConstantsSize */
-    /* skip val->maxMemoryAllocationCount */
-    /* skip val->maxSamplerAllocationCount */
-    /* skip val->bufferImageGranularity */
-    /* skip val->sparseAddressSpaceSize */
-    /* skip val->maxBoundDescriptorSets */
-    /* skip val->maxPerStageDescriptorSamplers */
-    /* skip val->maxPerStageDescriptorUniformBuffers */
-    /* skip val->maxPerStageDescriptorStorageBuffers */
-    /* skip val->maxPerStageDescriptorSampledImages */
-    /* skip val->maxPerStageDescriptorStorageImages */
-    /* skip val->maxPerStageDescriptorInputAttachments */
-    /* skip val->maxPerStageResources */
-    /* skip val->maxDescriptorSetSamplers */
-    /* skip val->maxDescriptorSetUniformBuffers */
-    /* skip val->maxDescriptorSetUniformBuffersDynamic */
-    /* skip val->maxDescriptorSetStorageBuffers */
-    /* skip val->maxDescriptorSetStorageBuffersDynamic */
-    /* skip val->maxDescriptorSetSampledImages */
-    /* skip val->maxDescriptorSetStorageImages */
-    /* skip val->maxDescriptorSetInputAttachments */
-    /* skip val->maxVertexInputAttributes */
-    /* skip val->maxVertexInputBindings */
-    /* skip val->maxVertexInputAttributeOffset */
-    /* skip val->maxVertexInputBindingStride */
-    /* skip val->maxVertexOutputComponents */
-    /* skip val->maxTessellationGenerationLevel */
-    /* skip val->maxTessellationPatchSize */
-    /* skip val->maxTessellationControlPerVertexInputComponents */
-    /* skip val->maxTessellationControlPerVertexOutputComponents */
-    /* skip val->maxTessellationControlPerPatchOutputComponents */
-    /* skip val->maxTessellationControlTotalOutputComponents */
-    /* skip val->maxTessellationEvaluationInputComponents */
-    /* skip val->maxTessellationEvaluationOutputComponents */
-    /* skip val->maxGeometryShaderInvocations */
-    /* skip val->maxGeometryInputComponents */
-    /* skip val->maxGeometryOutputComponents */
-    /* skip val->maxGeometryOutputVertices */
-    /* skip val->maxGeometryTotalOutputComponents */
-    /* skip val->maxFragmentInputComponents */
-    /* skip val->maxFragmentOutputAttachments */
-    /* skip val->maxFragmentDualSrcAttachments */
-    /* skip val->maxFragmentCombinedOutputResources */
-    /* skip val->maxComputeSharedMemorySize */
-    /* skip val->maxComputeWorkGroupCount */
-    /* skip val->maxComputeWorkGroupInvocations */
-    /* skip val->maxComputeWorkGroupSize */
-    /* skip val->subPixelPrecisionBits */
-    /* skip val->subTexelPrecisionBits */
-    /* skip val->mipmapPrecisionBits */
-    /* skip val->maxDrawIndexedIndexValue */
-    /* skip val->maxDrawIndirectCount */
-    /* skip val->maxSamplerLodBias */
-    /* skip val->maxSamplerAnisotropy */
-    /* skip val->maxViewports */
-    /* skip val->maxViewportDimensions */
-    /* skip val->viewportBoundsRange */
-    /* skip val->viewportSubPixelBits */
-    /* skip val->minMemoryMapAlignment */
-    /* skip val->minTexelBufferOffsetAlignment */
-    /* skip val->minUniformBufferOffsetAlignment */
-    /* skip val->minStorageBufferOffsetAlignment */
-    /* skip val->minTexelOffset */
-    /* skip val->maxTexelOffset */
-    /* skip val->minTexelGatherOffset */
-    /* skip val->maxTexelGatherOffset */
-    /* skip val->minInterpolationOffset */
-    /* skip val->maxInterpolationOffset */
-    /* skip val->subPixelInterpolationOffsetBits */
-    /* skip val->maxFramebufferWidth */
-    /* skip val->maxFramebufferHeight */
-    /* skip val->maxFramebufferLayers */
-    /* skip val->framebufferColorSampleCounts */
-    /* skip val->framebufferDepthSampleCounts */
-    /* skip val->framebufferStencilSampleCounts */
-    /* skip val->framebufferNoAttachmentsSampleCounts */
-    /* skip val->maxColorAttachments */
-    /* skip val->sampledImageColorSampleCounts */
-    /* skip val->sampledImageIntegerSampleCounts */
-    /* skip val->sampledImageDepthSampleCounts */
-    /* skip val->sampledImageStencilSampleCounts */
-    /* skip val->storageImageSampleCounts */
-    /* skip val->maxSampleMaskWords */
-    /* skip val->timestampComputeAndGraphics */
-    /* skip val->timestampPeriod */
-    /* skip val->maxClipDistances */
-    /* skip val->maxCullDistances */
-    /* skip val->maxCombinedClipAndCullDistances */
-    /* skip val->discreteQueuePriorities */
-    /* skip val->pointSizeRange */
-    /* skip val->lineWidthRange */
-    /* skip val->pointSizeGranularity */
-    /* skip val->lineWidthGranularity */
-    /* skip val->strictLines */
-    /* skip val->standardSampleLocations */
-    /* skip val->optimalBufferCopyOffsetAlignment */
-    /* skip val->optimalBufferCopyRowPitchAlignment */
-    /* skip val->nonCoherentAtomSize */
-}
-
-/* struct VkPhysicalDeviceSparseProperties */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkBool32(&val->residencyStandard2DBlockShape);
-    size += vn_sizeof_VkBool32(&val->residencyStandard2DMultisampleBlockShape);
-    size += vn_sizeof_VkBool32(&val->residencyStandard3DBlockShape);
-    size += vn_sizeof_VkBool32(&val->residencyAlignedMipSize);
-    size += vn_sizeof_VkBool32(&val->residencyNonResidentStrict);
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSparseProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSparseProperties *val)
-{
-    vn_decode_VkBool32(dec, &val->residencyStandard2DBlockShape);
-    vn_decode_VkBool32(dec, &val->residencyStandard2DMultisampleBlockShape);
-    vn_decode_VkBool32(dec, &val->residencyStandard3DBlockShape);
-    vn_decode_VkBool32(dec, &val->residencyAlignedMipSize);
-    vn_decode_VkBool32(dec, &val->residencyNonResidentStrict);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSparseProperties_partial(const VkPhysicalDeviceSparseProperties *val)
-{
-    size_t size = 0;
-    /* skip val->residencyStandard2DBlockShape */
-    /* skip val->residencyStandard2DMultisampleBlockShape */
-    /* skip val->residencyStandard3DBlockShape */
-    /* skip val->residencyAlignedMipSize */
-    /* skip val->residencyNonResidentStrict */
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSparseProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseProperties *val)
-{
-    /* skip val->residencyStandard2DBlockShape */
-    /* skip val->residencyStandard2DMultisampleBlockShape */
-    /* skip val->residencyStandard3DBlockShape */
-    /* skip val->residencyAlignedMipSize */
-    /* skip val->residencyNonResidentStrict */
-}
-
-/* struct VkPhysicalDeviceProperties */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->apiVersion);
-    size += vn_sizeof_uint32_t(&val->driverVersion);
-    size += vn_sizeof_uint32_t(&val->vendorID);
-    size += vn_sizeof_uint32_t(&val->deviceID);
-    size += vn_sizeof_VkPhysicalDeviceType(&val->deviceType);
-    size += vn_sizeof_array_size(VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
-    size += vn_sizeof_blob_array(val->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
-    size += vn_sizeof_array_size(VK_UUID_SIZE);
-    size += vn_sizeof_uint8_t_array(val->pipelineCacheUUID, VK_UUID_SIZE);
-    size += vn_sizeof_VkPhysicalDeviceLimits(&val->limits);
-    size += vn_sizeof_VkPhysicalDeviceSparseProperties(&val->sparseProperties);
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties *val)
-{
-    vn_decode_uint32_t(dec, &val->apiVersion);
-    vn_decode_uint32_t(dec, &val->driverVersion);
-    vn_decode_uint32_t(dec, &val->vendorID);
-    vn_decode_uint32_t(dec, &val->deviceID);
-    vn_decode_VkPhysicalDeviceType(dec, &val->deviceType);
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
-        vn_decode_blob_array(dec, val->deviceName, array_size);
-    }
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
-        vn_decode_uint8_t_array(dec, val->pipelineCacheUUID, array_size);
-    }
-    vn_decode_VkPhysicalDeviceLimits(dec, &val->limits);
-    vn_decode_VkPhysicalDeviceSparseProperties(dec, &val->sparseProperties);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProperties_partial(const VkPhysicalDeviceProperties *val)
-{
-    size_t size = 0;
-    /* skip val->apiVersion */
-    /* skip val->driverVersion */
-    /* skip val->vendorID */
-    /* skip val->deviceID */
-    /* skip val->deviceType */
-    /* skip val->deviceName */
-    /* skip val->pipelineCacheUUID */
-    size += vn_sizeof_VkPhysicalDeviceLimits_partial(&val->limits);
-    size += vn_sizeof_VkPhysicalDeviceSparseProperties_partial(&val->sparseProperties);
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties *val)
-{
-    /* skip val->apiVersion */
-    /* skip val->driverVersion */
-    /* skip val->vendorID */
-    /* skip val->deviceID */
-    /* skip val->deviceType */
-    /* skip val->deviceName */
-    /* skip val->pipelineCacheUUID */
-    vn_encode_VkPhysicalDeviceLimits_partial(enc, &val->limits);
-    vn_encode_VkPhysicalDeviceSparseProperties_partial(enc, &val->sparseProperties);
-}
-
-/* struct VkExtensionProperties */
-
-static inline size_t
-vn_sizeof_VkExtensionProperties(const VkExtensionProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
-    size += vn_sizeof_blob_array(val->extensionName, VK_MAX_EXTENSION_NAME_SIZE);
-    size += vn_sizeof_uint32_t(&val->specVersion);
-    return size;
-}
-
-static inline void
-vn_decode_VkExtensionProperties(struct vn_cs_decoder *dec, VkExtensionProperties *val)
-{
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
-        vn_decode_blob_array(dec, val->extensionName, array_size);
-    }
-    vn_decode_uint32_t(dec, &val->specVersion);
-}
-
-static inline size_t
-vn_sizeof_VkExtensionProperties_partial(const VkExtensionProperties *val)
-{
-    size_t size = 0;
-    /* skip val->extensionName */
-    /* skip val->specVersion */
-    return size;
-}
-
-static inline void
-vn_encode_VkExtensionProperties_partial(struct vn_cs_encoder *enc, const VkExtensionProperties *val)
-{
-    /* skip val->extensionName */
-    /* skip val->specVersion */
-}
-
-/* struct VkLayerProperties */
-
-static inline size_t
-vn_sizeof_VkLayerProperties(const VkLayerProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
-    size += vn_sizeof_blob_array(val->layerName, VK_MAX_EXTENSION_NAME_SIZE);
-    size += vn_sizeof_uint32_t(&val->specVersion);
-    size += vn_sizeof_uint32_t(&val->implementationVersion);
-    size += vn_sizeof_array_size(VK_MAX_DESCRIPTION_SIZE);
-    size += vn_sizeof_blob_array(val->description, VK_MAX_DESCRIPTION_SIZE);
-    return size;
-}
-
-static inline void
-vn_decode_VkLayerProperties(struct vn_cs_decoder *dec, VkLayerProperties *val)
-{
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
-        vn_decode_blob_array(dec, val->layerName, array_size);
-    }
-    vn_decode_uint32_t(dec, &val->specVersion);
-    vn_decode_uint32_t(dec, &val->implementationVersion);
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_MAX_DESCRIPTION_SIZE);
-        vn_decode_blob_array(dec, val->description, array_size);
-    }
-}
-
-static inline size_t
-vn_sizeof_VkLayerProperties_partial(const VkLayerProperties *val)
-{
-    size_t size = 0;
-    /* skip val->layerName */
-    /* skip val->specVersion */
-    /* skip val->implementationVersion */
-    /* skip val->description */
-    return size;
-}
-
-static inline void
-vn_encode_VkLayerProperties_partial(struct vn_cs_encoder *enc, const VkLayerProperties *val)
-{
-    /* skip val->layerName */
-    /* skip val->specVersion */
-    /* skip val->implementationVersion */
-    /* skip val->description */
-}
-
-/* struct VkApplicationInfo chain */
-
-static inline size_t
-vn_sizeof_VkApplicationInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkApplicationInfo_self(const VkApplicationInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    if (val->pApplicationName) {
-        const size_t string_size = strlen(val->pApplicationName) + 1;
-        size += vn_sizeof_array_size(string_size);
-        size += vn_sizeof_blob_array(val->pApplicationName, string_size);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->applicationVersion);
-    if (val->pEngineName) {
-        const size_t string_size = strlen(val->pEngineName) + 1;
-        size += vn_sizeof_array_size(string_size);
-        size += vn_sizeof_blob_array(val->pEngineName, string_size);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->engineVersion);
-    size += vn_sizeof_uint32_t(&val->apiVersion);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkApplicationInfo(const VkApplicationInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkApplicationInfo_pnext(val->pNext);
-    size += vn_sizeof_VkApplicationInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkApplicationInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkApplicationInfo_self(struct vn_cs_encoder *enc, const VkApplicationInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    if (val->pApplicationName) {
-        const size_t string_size = strlen(val->pApplicationName) + 1;
-        vn_encode_array_size(enc, string_size);
-        vn_encode_blob_array(enc, val->pApplicationName, string_size);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->applicationVersion);
-    if (val->pEngineName) {
-        const size_t string_size = strlen(val->pEngineName) + 1;
-        vn_encode_array_size(enc, string_size);
-        vn_encode_blob_array(enc, val->pEngineName, string_size);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->engineVersion);
-    vn_encode_uint32_t(enc, &val->apiVersion);
-}
-
-static inline void
-vn_encode_VkApplicationInfo(struct vn_cs_encoder *enc, const VkApplicationInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_APPLICATION_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_APPLICATION_INFO });
-    vn_encode_VkApplicationInfo_pnext(enc, val->pNext);
-    vn_encode_VkApplicationInfo_self(enc, val);
-}
-
-/* struct VkDeviceQueueCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkDeviceQueueCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDeviceQueueCreateInfo_self(const VkDeviceQueueCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
-    size += vn_sizeof_uint32_t(&val->queueCount);
-    if (val->pQueuePriorities) {
-        size += vn_sizeof_array_size(val->queueCount);
-        size += vn_sizeof_float_array(val->pQueuePriorities, val->queueCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDeviceQueueCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDeviceQueueCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDeviceQueueCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDeviceQueueCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceQueueCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->queueFamilyIndex);
-    vn_encode_uint32_t(enc, &val->queueCount);
-    if (val->pQueuePriorities) {
-        vn_encode_array_size(enc, val->queueCount);
-        vn_encode_float_array(enc, val->pQueuePriorities, val->queueCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkDeviceQueueCreateInfo(struct vn_cs_encoder *enc, const VkDeviceQueueCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO });
-    vn_encode_VkDeviceQueueCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkDeviceQueueCreateInfo_self(enc, val);
-}
-
-/* struct VkPhysicalDeviceFeatures */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkBool32(&val->robustBufferAccess);
-    size += vn_sizeof_VkBool32(&val->fullDrawIndexUint32);
-    size += vn_sizeof_VkBool32(&val->imageCubeArray);
-    size += vn_sizeof_VkBool32(&val->independentBlend);
-    size += vn_sizeof_VkBool32(&val->geometryShader);
-    size += vn_sizeof_VkBool32(&val->tessellationShader);
-    size += vn_sizeof_VkBool32(&val->sampleRateShading);
-    size += vn_sizeof_VkBool32(&val->dualSrcBlend);
-    size += vn_sizeof_VkBool32(&val->logicOp);
-    size += vn_sizeof_VkBool32(&val->multiDrawIndirect);
-    size += vn_sizeof_VkBool32(&val->drawIndirectFirstInstance);
-    size += vn_sizeof_VkBool32(&val->depthClamp);
-    size += vn_sizeof_VkBool32(&val->depthBiasClamp);
-    size += vn_sizeof_VkBool32(&val->fillModeNonSolid);
-    size += vn_sizeof_VkBool32(&val->depthBounds);
-    size += vn_sizeof_VkBool32(&val->wideLines);
-    size += vn_sizeof_VkBool32(&val->largePoints);
-    size += vn_sizeof_VkBool32(&val->alphaToOne);
-    size += vn_sizeof_VkBool32(&val->multiViewport);
-    size += vn_sizeof_VkBool32(&val->samplerAnisotropy);
-    size += vn_sizeof_VkBool32(&val->textureCompressionETC2);
-    size += vn_sizeof_VkBool32(&val->textureCompressionASTC_LDR);
-    size += vn_sizeof_VkBool32(&val->textureCompressionBC);
-    size += vn_sizeof_VkBool32(&val->occlusionQueryPrecise);
-    size += vn_sizeof_VkBool32(&val->pipelineStatisticsQuery);
-    size += vn_sizeof_VkBool32(&val->vertexPipelineStoresAndAtomics);
-    size += vn_sizeof_VkBool32(&val->fragmentStoresAndAtomics);
-    size += vn_sizeof_VkBool32(&val->shaderTessellationAndGeometryPointSize);
-    size += vn_sizeof_VkBool32(&val->shaderImageGatherExtended);
-    size += vn_sizeof_VkBool32(&val->shaderStorageImageExtendedFormats);
-    size += vn_sizeof_VkBool32(&val->shaderStorageImageMultisample);
-    size += vn_sizeof_VkBool32(&val->shaderStorageImageReadWithoutFormat);
-    size += vn_sizeof_VkBool32(&val->shaderStorageImageWriteWithoutFormat);
-    size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayDynamicIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayDynamicIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayDynamicIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayDynamicIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderClipDistance);
-    size += vn_sizeof_VkBool32(&val->shaderCullDistance);
-    size += vn_sizeof_VkBool32(&val->shaderFloat64);
-    size += vn_sizeof_VkBool32(&val->shaderInt64);
-    size += vn_sizeof_VkBool32(&val->shaderInt16);
-    size += vn_sizeof_VkBool32(&val->shaderResourceResidency);
-    size += vn_sizeof_VkBool32(&val->shaderResourceMinLod);
-    size += vn_sizeof_VkBool32(&val->sparseBinding);
-    size += vn_sizeof_VkBool32(&val->sparseResidencyBuffer);
-    size += vn_sizeof_VkBool32(&val->sparseResidencyImage2D);
-    size += vn_sizeof_VkBool32(&val->sparseResidencyImage3D);
-    size += vn_sizeof_VkBool32(&val->sparseResidency2Samples);
-    size += vn_sizeof_VkBool32(&val->sparseResidency4Samples);
-    size += vn_sizeof_VkBool32(&val->sparseResidency8Samples);
-    size += vn_sizeof_VkBool32(&val->sparseResidency16Samples);
-    size += vn_sizeof_VkBool32(&val->sparseResidencyAliased);
-    size += vn_sizeof_VkBool32(&val->variableMultisampleRate);
-    size += vn_sizeof_VkBool32(&val->inheritedQueries);
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val)
-{
-    vn_encode_VkBool32(enc, &val->robustBufferAccess);
-    vn_encode_VkBool32(enc, &val->fullDrawIndexUint32);
-    vn_encode_VkBool32(enc, &val->imageCubeArray);
-    vn_encode_VkBool32(enc, &val->independentBlend);
-    vn_encode_VkBool32(enc, &val->geometryShader);
-    vn_encode_VkBool32(enc, &val->tessellationShader);
-    vn_encode_VkBool32(enc, &val->sampleRateShading);
-    vn_encode_VkBool32(enc, &val->dualSrcBlend);
-    vn_encode_VkBool32(enc, &val->logicOp);
-    vn_encode_VkBool32(enc, &val->multiDrawIndirect);
-    vn_encode_VkBool32(enc, &val->drawIndirectFirstInstance);
-    vn_encode_VkBool32(enc, &val->depthClamp);
-    vn_encode_VkBool32(enc, &val->depthBiasClamp);
-    vn_encode_VkBool32(enc, &val->fillModeNonSolid);
-    vn_encode_VkBool32(enc, &val->depthBounds);
-    vn_encode_VkBool32(enc, &val->wideLines);
-    vn_encode_VkBool32(enc, &val->largePoints);
-    vn_encode_VkBool32(enc, &val->alphaToOne);
-    vn_encode_VkBool32(enc, &val->multiViewport);
-    vn_encode_VkBool32(enc, &val->samplerAnisotropy);
-    vn_encode_VkBool32(enc, &val->textureCompressionETC2);
-    vn_encode_VkBool32(enc, &val->textureCompressionASTC_LDR);
-    vn_encode_VkBool32(enc, &val->textureCompressionBC);
-    vn_encode_VkBool32(enc, &val->occlusionQueryPrecise);
-    vn_encode_VkBool32(enc, &val->pipelineStatisticsQuery);
-    vn_encode_VkBool32(enc, &val->vertexPipelineStoresAndAtomics);
-    vn_encode_VkBool32(enc, &val->fragmentStoresAndAtomics);
-    vn_encode_VkBool32(enc, &val->shaderTessellationAndGeometryPointSize);
-    vn_encode_VkBool32(enc, &val->shaderImageGatherExtended);
-    vn_encode_VkBool32(enc, &val->shaderStorageImageExtendedFormats);
-    vn_encode_VkBool32(enc, &val->shaderStorageImageMultisample);
-    vn_encode_VkBool32(enc, &val->shaderStorageImageReadWithoutFormat);
-    vn_encode_VkBool32(enc, &val->shaderStorageImageWriteWithoutFormat);
-    vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayDynamicIndexing);
-    vn_encode_VkBool32(enc, &val->shaderSampledImageArrayDynamicIndexing);
-    vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayDynamicIndexing);
-    vn_encode_VkBool32(enc, &val->shaderStorageImageArrayDynamicIndexing);
-    vn_encode_VkBool32(enc, &val->shaderClipDistance);
-    vn_encode_VkBool32(enc, &val->shaderCullDistance);
-    vn_encode_VkBool32(enc, &val->shaderFloat64);
-    vn_encode_VkBool32(enc, &val->shaderInt64);
-    vn_encode_VkBool32(enc, &val->shaderInt16);
-    vn_encode_VkBool32(enc, &val->shaderResourceResidency);
-    vn_encode_VkBool32(enc, &val->shaderResourceMinLod);
-    vn_encode_VkBool32(enc, &val->sparseBinding);
-    vn_encode_VkBool32(enc, &val->sparseResidencyBuffer);
-    vn_encode_VkBool32(enc, &val->sparseResidencyImage2D);
-    vn_encode_VkBool32(enc, &val->sparseResidencyImage3D);
-    vn_encode_VkBool32(enc, &val->sparseResidency2Samples);
-    vn_encode_VkBool32(enc, &val->sparseResidency4Samples);
-    vn_encode_VkBool32(enc, &val->sparseResidency8Samples);
-    vn_encode_VkBool32(enc, &val->sparseResidency16Samples);
-    vn_encode_VkBool32(enc, &val->sparseResidencyAliased);
-    vn_encode_VkBool32(enc, &val->variableMultisampleRate);
-    vn_encode_VkBool32(enc, &val->inheritedQueries);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures *val)
-{
-    vn_decode_VkBool32(dec, &val->robustBufferAccess);
-    vn_decode_VkBool32(dec, &val->fullDrawIndexUint32);
-    vn_decode_VkBool32(dec, &val->imageCubeArray);
-    vn_decode_VkBool32(dec, &val->independentBlend);
-    vn_decode_VkBool32(dec, &val->geometryShader);
-    vn_decode_VkBool32(dec, &val->tessellationShader);
-    vn_decode_VkBool32(dec, &val->sampleRateShading);
-    vn_decode_VkBool32(dec, &val->dualSrcBlend);
-    vn_decode_VkBool32(dec, &val->logicOp);
-    vn_decode_VkBool32(dec, &val->multiDrawIndirect);
-    vn_decode_VkBool32(dec, &val->drawIndirectFirstInstance);
-    vn_decode_VkBool32(dec, &val->depthClamp);
-    vn_decode_VkBool32(dec, &val->depthBiasClamp);
-    vn_decode_VkBool32(dec, &val->fillModeNonSolid);
-    vn_decode_VkBool32(dec, &val->depthBounds);
-    vn_decode_VkBool32(dec, &val->wideLines);
-    vn_decode_VkBool32(dec, &val->largePoints);
-    vn_decode_VkBool32(dec, &val->alphaToOne);
-    vn_decode_VkBool32(dec, &val->multiViewport);
-    vn_decode_VkBool32(dec, &val->samplerAnisotropy);
-    vn_decode_VkBool32(dec, &val->textureCompressionETC2);
-    vn_decode_VkBool32(dec, &val->textureCompressionASTC_LDR);
-    vn_decode_VkBool32(dec, &val->textureCompressionBC);
-    vn_decode_VkBool32(dec, &val->occlusionQueryPrecise);
-    vn_decode_VkBool32(dec, &val->pipelineStatisticsQuery);
-    vn_decode_VkBool32(dec, &val->vertexPipelineStoresAndAtomics);
-    vn_decode_VkBool32(dec, &val->fragmentStoresAndAtomics);
-    vn_decode_VkBool32(dec, &val->shaderTessellationAndGeometryPointSize);
-    vn_decode_VkBool32(dec, &val->shaderImageGatherExtended);
-    vn_decode_VkBool32(dec, &val->shaderStorageImageExtendedFormats);
-    vn_decode_VkBool32(dec, &val->shaderStorageImageMultisample);
-    vn_decode_VkBool32(dec, &val->shaderStorageImageReadWithoutFormat);
-    vn_decode_VkBool32(dec, &val->shaderStorageImageWriteWithoutFormat);
-    vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayDynamicIndexing);
-    vn_decode_VkBool32(dec, &val->shaderSampledImageArrayDynamicIndexing);
-    vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayDynamicIndexing);
-    vn_decode_VkBool32(dec, &val->shaderStorageImageArrayDynamicIndexing);
-    vn_decode_VkBool32(dec, &val->shaderClipDistance);
-    vn_decode_VkBool32(dec, &val->shaderCullDistance);
-    vn_decode_VkBool32(dec, &val->shaderFloat64);
-    vn_decode_VkBool32(dec, &val->shaderInt64);
-    vn_decode_VkBool32(dec, &val->shaderInt16);
-    vn_decode_VkBool32(dec, &val->shaderResourceResidency);
-    vn_decode_VkBool32(dec, &val->shaderResourceMinLod);
-    vn_decode_VkBool32(dec, &val->sparseBinding);
-    vn_decode_VkBool32(dec, &val->sparseResidencyBuffer);
-    vn_decode_VkBool32(dec, &val->sparseResidencyImage2D);
-    vn_decode_VkBool32(dec, &val->sparseResidencyImage3D);
-    vn_decode_VkBool32(dec, &val->sparseResidency2Samples);
-    vn_decode_VkBool32(dec, &val->sparseResidency4Samples);
-    vn_decode_VkBool32(dec, &val->sparseResidency8Samples);
-    vn_decode_VkBool32(dec, &val->sparseResidency16Samples);
-    vn_decode_VkBool32(dec, &val->sparseResidencyAliased);
-    vn_decode_VkBool32(dec, &val->variableMultisampleRate);
-    vn_decode_VkBool32(dec, &val->inheritedQueries);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFeatures_partial(const VkPhysicalDeviceFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->robustBufferAccess */
-    /* skip val->fullDrawIndexUint32 */
-    /* skip val->imageCubeArray */
-    /* skip val->independentBlend */
-    /* skip val->geometryShader */
-    /* skip val->tessellationShader */
-    /* skip val->sampleRateShading */
-    /* skip val->dualSrcBlend */
-    /* skip val->logicOp */
-    /* skip val->multiDrawIndirect */
-    /* skip val->drawIndirectFirstInstance */
-    /* skip val->depthClamp */
-    /* skip val->depthBiasClamp */
-    /* skip val->fillModeNonSolid */
-    /* skip val->depthBounds */
-    /* skip val->wideLines */
-    /* skip val->largePoints */
-    /* skip val->alphaToOne */
-    /* skip val->multiViewport */
-    /* skip val->samplerAnisotropy */
-    /* skip val->textureCompressionETC2 */
-    /* skip val->textureCompressionASTC_LDR */
-    /* skip val->textureCompressionBC */
-    /* skip val->occlusionQueryPrecise */
-    /* skip val->pipelineStatisticsQuery */
-    /* skip val->vertexPipelineStoresAndAtomics */
-    /* skip val->fragmentStoresAndAtomics */
-    /* skip val->shaderTessellationAndGeometryPointSize */
-    /* skip val->shaderImageGatherExtended */
-    /* skip val->shaderStorageImageExtendedFormats */
-    /* skip val->shaderStorageImageMultisample */
-    /* skip val->shaderStorageImageReadWithoutFormat */
-    /* skip val->shaderStorageImageWriteWithoutFormat */
-    /* skip val->shaderUniformBufferArrayDynamicIndexing */
-    /* skip val->shaderSampledImageArrayDynamicIndexing */
-    /* skip val->shaderStorageBufferArrayDynamicIndexing */
-    /* skip val->shaderStorageImageArrayDynamicIndexing */
-    /* skip val->shaderClipDistance */
-    /* skip val->shaderCullDistance */
-    /* skip val->shaderFloat64 */
-    /* skip val->shaderInt64 */
-    /* skip val->shaderInt16 */
-    /* skip val->shaderResourceResidency */
-    /* skip val->shaderResourceMinLod */
-    /* skip val->sparseBinding */
-    /* skip val->sparseResidencyBuffer */
-    /* skip val->sparseResidencyImage2D */
-    /* skip val->sparseResidencyImage3D */
-    /* skip val->sparseResidency2Samples */
-    /* skip val->sparseResidency4Samples */
-    /* skip val->sparseResidency8Samples */
-    /* skip val->sparseResidency16Samples */
-    /* skip val->sparseResidencyAliased */
-    /* skip val->variableMultisampleRate */
-    /* skip val->inheritedQueries */
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val)
-{
-    /* skip val->robustBufferAccess */
-    /* skip val->fullDrawIndexUint32 */
-    /* skip val->imageCubeArray */
-    /* skip val->independentBlend */
-    /* skip val->geometryShader */
-    /* skip val->tessellationShader */
-    /* skip val->sampleRateShading */
-    /* skip val->dualSrcBlend */
-    /* skip val->logicOp */
-    /* skip val->multiDrawIndirect */
-    /* skip val->drawIndirectFirstInstance */
-    /* skip val->depthClamp */
-    /* skip val->depthBiasClamp */
-    /* skip val->fillModeNonSolid */
-    /* skip val->depthBounds */
-    /* skip val->wideLines */
-    /* skip val->largePoints */
-    /* skip val->alphaToOne */
-    /* skip val->multiViewport */
-    /* skip val->samplerAnisotropy */
-    /* skip val->textureCompressionETC2 */
-    /* skip val->textureCompressionASTC_LDR */
-    /* skip val->textureCompressionBC */
-    /* skip val->occlusionQueryPrecise */
-    /* skip val->pipelineStatisticsQuery */
-    /* skip val->vertexPipelineStoresAndAtomics */
-    /* skip val->fragmentStoresAndAtomics */
-    /* skip val->shaderTessellationAndGeometryPointSize */
-    /* skip val->shaderImageGatherExtended */
-    /* skip val->shaderStorageImageExtendedFormats */
-    /* skip val->shaderStorageImageMultisample */
-    /* skip val->shaderStorageImageReadWithoutFormat */
-    /* skip val->shaderStorageImageWriteWithoutFormat */
-    /* skip val->shaderUniformBufferArrayDynamicIndexing */
-    /* skip val->shaderSampledImageArrayDynamicIndexing */
-    /* skip val->shaderStorageBufferArrayDynamicIndexing */
-    /* skip val->shaderStorageImageArrayDynamicIndexing */
-    /* skip val->shaderClipDistance */
-    /* skip val->shaderCullDistance */
-    /* skip val->shaderFloat64 */
-    /* skip val->shaderInt64 */
-    /* skip val->shaderInt16 */
-    /* skip val->shaderResourceResidency */
-    /* skip val->shaderResourceMinLod */
-    /* skip val->sparseBinding */
-    /* skip val->sparseResidencyBuffer */
-    /* skip val->sparseResidencyImage2D */
-    /* skip val->sparseResidencyImage3D */
-    /* skip val->sparseResidency2Samples */
-    /* skip val->sparseResidency4Samples */
-    /* skip val->sparseResidency8Samples */
-    /* skip val->sparseResidency16Samples */
-    /* skip val->sparseResidencyAliased */
-    /* skip val->variableMultisampleRate */
-    /* skip val->inheritedQueries */
-}
-
-/* struct VkPhysicalDeviceVariablePointersFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(const VkPhysicalDeviceVariablePointersFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
-    size += vn_sizeof_VkBool32(&val->variablePointers);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
-    vn_encode_VkBool32(enc, &val->variablePointers);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
-    vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
-    vn_decode_VkBool32(dec, &val->variablePointers);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(const VkPhysicalDeviceVariablePointersFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->variablePointersStorageBuffer */
-    /* skip val->variablePointers */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_partial(const VkPhysicalDeviceVariablePointersFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->variablePointersStorageBuffer */
-    /* skip val->variablePointers */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVariablePointersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
-    vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceMultiviewFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(const VkPhysicalDeviceMultiviewFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->multiview);
-    size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
-    size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->multiview);
-    vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
-    vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
-    vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->multiview);
-    vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
-    vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(const VkPhysicalDeviceMultiviewFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->multiview */
-    /* skip val->multiviewGeometryShader */
-    /* skip val->multiviewTessellationShader */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewFeatures_partial(const VkPhysicalDeviceMultiviewFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->multiview */
-    /* skip val->multiviewGeometryShader */
-    /* skip val->multiviewTessellationShader */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMultiviewFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
-    vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDevice16BitStorageFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(const VkPhysicalDevice16BitStorageFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
-    size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
-    size += vn_sizeof_VkBool32(&val->storagePushConstant16);
-    size += vn_sizeof_VkBool32(&val->storageInputOutput16);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
-    vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
-    vn_encode_VkBool32(enc, &val->storagePushConstant16);
-    vn_encode_VkBool32(enc, &val->storageInputOutput16);
-}
-
-static inline void
-vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
-    vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
-    vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
-    vn_decode_VkBool32(dec, &val->storagePushConstant16);
-    vn_decode_VkBool32(dec, &val->storageInputOutput16);
-}
-
-static inline void
-vn_decode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(const VkPhysicalDevice16BitStorageFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->storageBuffer16BitAccess */
-    /* skip val->uniformAndStorageBuffer16BitAccess */
-    /* skip val->storagePushConstant16 */
-    /* skip val->storageInputOutput16 */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice16BitStorageFeatures_partial(const VkPhysicalDevice16BitStorageFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->storageBuffer16BitAccess */
-    /* skip val->uniformAndStorageBuffer16BitAccess */
-    /* skip val->storagePushConstant16 */
-    /* skip val->storageInputOutput16 */
-}
-
-static inline void
-vn_encode_VkPhysicalDevice16BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
-    vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
-    vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->shaderSubgroupExtendedTypes */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->shaderSubgroupExtendedTypes */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
-    vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceSamplerYcbcrConversionFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
-    vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->samplerYcbcrConversion */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->samplerYcbcrConversion */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
-    vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceProtectedMemoryFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(const VkPhysicalDeviceProtectedMemoryFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->protectedMemory);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->protectedMemory);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
-    vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->protectedMemory);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->protectedMemory */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->protectedMemory */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
-    vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceShaderDrawParametersFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->shaderDrawParameters);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
-    vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->shaderDrawParameters);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->shaderDrawParameters */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->shaderDrawParameters */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
-    vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceShaderFloat16Int8Features chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->shaderFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderInt8);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->shaderFloat16);
-    vn_encode_VkBool32(enc, &val->shaderInt8);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
-    vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->shaderFloat16);
-    vn_decode_VkBool32(dec, &val->shaderInt8);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->shaderFloat16 */
-    /* skip val->shaderInt8 */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->shaderFloat16 */
-    /* skip val->shaderInt8 */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
-    vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceHostQueryResetFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->hostQueryReset);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->hostQueryReset);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
-    vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->hostQueryReset);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->hostQueryReset */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->hostQueryReset */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
-    vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceDescriptorIndexingFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
-    size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
-    vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
-    vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
-    vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
-    vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
-    vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
-    vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
-    vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
-    vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
-    vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
-    vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
-    vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
-    vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
-    vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->shaderInputAttachmentArrayDynamicIndexing */
-    /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
-    /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
-    /* skip val->shaderUniformBufferArrayNonUniformIndexing */
-    /* skip val->shaderSampledImageArrayNonUniformIndexing */
-    /* skip val->shaderStorageBufferArrayNonUniformIndexing */
-    /* skip val->shaderStorageImageArrayNonUniformIndexing */
-    /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
-    /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
-    /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
-    /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
-    /* skip val->descriptorBindingSampledImageUpdateAfterBind */
-    /* skip val->descriptorBindingStorageImageUpdateAfterBind */
-    /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
-    /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
-    /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
-    /* skip val->descriptorBindingUpdateUnusedWhilePending */
-    /* skip val->descriptorBindingPartiallyBound */
-    /* skip val->descriptorBindingVariableDescriptorCount */
-    /* skip val->runtimeDescriptorArray */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->shaderInputAttachmentArrayDynamicIndexing */
-    /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
-    /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
-    /* skip val->shaderUniformBufferArrayNonUniformIndexing */
-    /* skip val->shaderSampledImageArrayNonUniformIndexing */
-    /* skip val->shaderStorageBufferArrayNonUniformIndexing */
-    /* skip val->shaderStorageImageArrayNonUniformIndexing */
-    /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
-    /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
-    /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
-    /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
-    /* skip val->descriptorBindingSampledImageUpdateAfterBind */
-    /* skip val->descriptorBindingStorageImageUpdateAfterBind */
-    /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
-    /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
-    /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
-    /* skip val->descriptorBindingUpdateUnusedWhilePending */
-    /* skip val->descriptorBindingPartiallyBound */
-    /* skip val->descriptorBindingVariableDescriptorCount */
-    /* skip val->runtimeDescriptorArray */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
-    vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceTimelineSemaphoreFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->timelineSemaphore);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->timelineSemaphore);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
-    vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->timelineSemaphore);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->timelineSemaphore */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->timelineSemaphore */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
-    vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDevice8BitStorageFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
-    size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
-    size += vn_sizeof_VkBool32(&val->storagePushConstant8);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
-    vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
-    vn_encode_VkBool32(enc, &val->storagePushConstant8);
-}
-
-static inline void
-vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
-    vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
-    vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
-    vn_decode_VkBool32(dec, &val->storagePushConstant8);
-}
-
-static inline void
-vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->storageBuffer8BitAccess */
-    /* skip val->uniformAndStorageBuffer8BitAccess */
-    /* skip val->storagePushConstant8 */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->storageBuffer8BitAccess */
-    /* skip val->uniformAndStorageBuffer8BitAccess */
-    /* skip val->storagePushConstant8 */
-}
-
-static inline void
-vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
-    vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceVulkanMemoryModelFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
-    size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
-    size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
-    vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
-    vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
-    vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
-    vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
-    vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->vulkanMemoryModel */
-    /* skip val->vulkanMemoryModelDeviceScope */
-    /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->vulkanMemoryModel */
-    /* skip val->vulkanMemoryModelDeviceScope */
-    /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
-    vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceShaderAtomicInt64Features chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
-    size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
-    vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
-    vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
-    vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->shaderBufferInt64Atomics */
-    /* skip val->shaderSharedInt64Atomics */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->shaderBufferInt64Atomics */
-    /* skip val->shaderSharedInt64Atomics */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
-    vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceTransformFeedbackFeaturesEXT chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->transformFeedback);
-    size += vn_sizeof_VkBool32(&val->geometryStreams);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->transformFeedback);
-    vn_encode_VkBool32(enc, &val->geometryStreams);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
-    vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->transformFeedback);
-    vn_decode_VkBool32(dec, &val->geometryStreams);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->transformFeedback */
-    /* skip val->geometryStreams */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->transformFeedback */
-    /* skip val->geometryStreams */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
-    vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceScalarBlockLayoutFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->scalarBlockLayout);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
-    vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->scalarBlockLayout);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->scalarBlockLayout */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->scalarBlockLayout */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
-    vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
-    vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->uniformBufferStandardLayout */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->uniformBufferStandardLayout */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
-    vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceBufferDeviceAddressFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
-    size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
-    size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
-    vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
-    vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
-    vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
-    vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
-    vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->bufferDeviceAddress */
-    /* skip val->bufferDeviceAddressCaptureReplay */
-    /* skip val->bufferDeviceAddressMultiDevice */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->bufferDeviceAddress */
-    /* skip val->bufferDeviceAddressCaptureReplay */
-    /* skip val->bufferDeviceAddressMultiDevice */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
-    vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceImagelessFramebufferFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
-    vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->imagelessFramebuffer */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->imagelessFramebuffer */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
-    vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
-    vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->separateDepthStencilLayouts */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->separateDepthStencilLayouts */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
-    vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceVulkan11Features chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
-    size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
-    size += vn_sizeof_VkBool32(&val->storagePushConstant16);
-    size += vn_sizeof_VkBool32(&val->storageInputOutput16);
-    size += vn_sizeof_VkBool32(&val->multiview);
-    size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
-    size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
-    size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
-    size += vn_sizeof_VkBool32(&val->variablePointers);
-    size += vn_sizeof_VkBool32(&val->protectedMemory);
-    size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
-    size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
-    vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
-    vn_encode_VkBool32(enc, &val->storagePushConstant16);
-    vn_encode_VkBool32(enc, &val->storageInputOutput16);
-    vn_encode_VkBool32(enc, &val->multiview);
-    vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
-    vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
-    vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
-    vn_encode_VkBool32(enc, &val->variablePointers);
-    vn_encode_VkBool32(enc, &val->protectedMemory);
-    vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
-    vn_encode_VkBool32(enc, &val->shaderDrawParameters);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
-    vn_encode_VkPhysicalDeviceVulkan11Features_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
-    vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
-    vn_decode_VkBool32(dec, &val->storagePushConstant16);
-    vn_decode_VkBool32(dec, &val->storageInputOutput16);
-    vn_decode_VkBool32(dec, &val->multiview);
-    vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
-    vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
-    vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
-    vn_decode_VkBool32(dec, &val->variablePointers);
-    vn_decode_VkBool32(dec, &val->protectedMemory);
-    vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
-    vn_decode_VkBool32(dec, &val->shaderDrawParameters);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceVulkan11Features_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->storageBuffer16BitAccess */
-    /* skip val->uniformAndStorageBuffer16BitAccess */
-    /* skip val->storagePushConstant16 */
-    /* skip val->storageInputOutput16 */
-    /* skip val->multiview */
-    /* skip val->multiviewGeometryShader */
-    /* skip val->multiviewTessellationShader */
-    /* skip val->variablePointersStorageBuffer */
-    /* skip val->variablePointers */
-    /* skip val->protectedMemory */
-    /* skip val->samplerYcbcrConversion */
-    /* skip val->shaderDrawParameters */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->storageBuffer16BitAccess */
-    /* skip val->uniformAndStorageBuffer16BitAccess */
-    /* skip val->storagePushConstant16 */
-    /* skip val->storageInputOutput16 */
-    /* skip val->multiview */
-    /* skip val->multiviewGeometryShader */
-    /* skip val->multiviewTessellationShader */
-    /* skip val->variablePointersStorageBuffer */
-    /* skip val->variablePointers */
-    /* skip val->protectedMemory */
-    /* skip val->samplerYcbcrConversion */
-    /* skip val->shaderDrawParameters */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
-    vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceVulkan12Features chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->samplerMirrorClampToEdge);
-    size += vn_sizeof_VkBool32(&val->drawIndirectCount);
-    size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
-    size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
-    size += vn_sizeof_VkBool32(&val->storagePushConstant8);
-    size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
-    size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
-    size += vn_sizeof_VkBool32(&val->shaderFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderInt8);
-    size += vn_sizeof_VkBool32(&val->descriptorIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
-    size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
-    size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
-    size += vn_sizeof_VkBool32(&val->samplerFilterMinmax);
-    size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
-    size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
-    size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
-    size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
-    size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
-    size += vn_sizeof_VkBool32(&val->hostQueryReset);
-    size += vn_sizeof_VkBool32(&val->timelineSemaphore);
-    size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
-    size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
-    size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
-    size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
-    size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
-    size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
-    size += vn_sizeof_VkBool32(&val->shaderOutputViewportIndex);
-    size += vn_sizeof_VkBool32(&val->shaderOutputLayer);
-    size += vn_sizeof_VkBool32(&val->subgroupBroadcastDynamicId);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->samplerMirrorClampToEdge);
-    vn_encode_VkBool32(enc, &val->drawIndirectCount);
-    vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
-    vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
-    vn_encode_VkBool32(enc, &val->storagePushConstant8);
-    vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
-    vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
-    vn_encode_VkBool32(enc, &val->shaderFloat16);
-    vn_encode_VkBool32(enc, &val->shaderInt8);
-    vn_encode_VkBool32(enc, &val->descriptorIndexing);
-    vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
-    vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
-    vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
-    vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
-    vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
-    vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
-    vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
-    vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
-    vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
-    vn_encode_VkBool32(enc, &val->samplerFilterMinmax);
-    vn_encode_VkBool32(enc, &val->scalarBlockLayout);
-    vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
-    vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
-    vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
-    vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
-    vn_encode_VkBool32(enc, &val->hostQueryReset);
-    vn_encode_VkBool32(enc, &val->timelineSemaphore);
-    vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
-    vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
-    vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
-    vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
-    vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
-    vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
-    vn_encode_VkBool32(enc, &val->shaderOutputViewportIndex);
-    vn_encode_VkBool32(enc, &val->shaderOutputLayer);
-    vn_encode_VkBool32(enc, &val->subgroupBroadcastDynamicId);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
-    vn_encode_VkPhysicalDeviceVulkan12Features_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->samplerMirrorClampToEdge);
-    vn_decode_VkBool32(dec, &val->drawIndirectCount);
-    vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
-    vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
-    vn_decode_VkBool32(dec, &val->storagePushConstant8);
-    vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
-    vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
-    vn_decode_VkBool32(dec, &val->shaderFloat16);
-    vn_decode_VkBool32(dec, &val->shaderInt8);
-    vn_decode_VkBool32(dec, &val->descriptorIndexing);
-    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
-    vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
-    vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
-    vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
-    vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
-    vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
-    vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
-    vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
-    vn_decode_VkBool32(dec, &val->samplerFilterMinmax);
-    vn_decode_VkBool32(dec, &val->scalarBlockLayout);
-    vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
-    vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
-    vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
-    vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
-    vn_decode_VkBool32(dec, &val->hostQueryReset);
-    vn_decode_VkBool32(dec, &val->timelineSemaphore);
-    vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
-    vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
-    vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
-    vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
-    vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
-    vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
-    vn_decode_VkBool32(dec, &val->shaderOutputViewportIndex);
-    vn_decode_VkBool32(dec, &val->shaderOutputLayer);
-    vn_decode_VkBool32(dec, &val->subgroupBroadcastDynamicId);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceVulkan12Features_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->samplerMirrorClampToEdge */
-    /* skip val->drawIndirectCount */
-    /* skip val->storageBuffer8BitAccess */
-    /* skip val->uniformAndStorageBuffer8BitAccess */
-    /* skip val->storagePushConstant8 */
-    /* skip val->shaderBufferInt64Atomics */
-    /* skip val->shaderSharedInt64Atomics */
-    /* skip val->shaderFloat16 */
-    /* skip val->shaderInt8 */
-    /* skip val->descriptorIndexing */
-    /* skip val->shaderInputAttachmentArrayDynamicIndexing */
-    /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
-    /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
-    /* skip val->shaderUniformBufferArrayNonUniformIndexing */
-    /* skip val->shaderSampledImageArrayNonUniformIndexing */
-    /* skip val->shaderStorageBufferArrayNonUniformIndexing */
-    /* skip val->shaderStorageImageArrayNonUniformIndexing */
-    /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
-    /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
-    /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
-    /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
-    /* skip val->descriptorBindingSampledImageUpdateAfterBind */
-    /* skip val->descriptorBindingStorageImageUpdateAfterBind */
-    /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
-    /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
-    /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
-    /* skip val->descriptorBindingUpdateUnusedWhilePending */
-    /* skip val->descriptorBindingPartiallyBound */
-    /* skip val->descriptorBindingVariableDescriptorCount */
-    /* skip val->runtimeDescriptorArray */
-    /* skip val->samplerFilterMinmax */
-    /* skip val->scalarBlockLayout */
-    /* skip val->imagelessFramebuffer */
-    /* skip val->uniformBufferStandardLayout */
-    /* skip val->shaderSubgroupExtendedTypes */
-    /* skip val->separateDepthStencilLayouts */
-    /* skip val->hostQueryReset */
-    /* skip val->timelineSemaphore */
-    /* skip val->bufferDeviceAddress */
-    /* skip val->bufferDeviceAddressCaptureReplay */
-    /* skip val->bufferDeviceAddressMultiDevice */
-    /* skip val->vulkanMemoryModel */
-    /* skip val->vulkanMemoryModelDeviceScope */
-    /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
-    /* skip val->shaderOutputViewportIndex */
-    /* skip val->shaderOutputLayer */
-    /* skip val->subgroupBroadcastDynamicId */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->samplerMirrorClampToEdge */
-    /* skip val->drawIndirectCount */
-    /* skip val->storageBuffer8BitAccess */
-    /* skip val->uniformAndStorageBuffer8BitAccess */
-    /* skip val->storagePushConstant8 */
-    /* skip val->shaderBufferInt64Atomics */
-    /* skip val->shaderSharedInt64Atomics */
-    /* skip val->shaderFloat16 */
-    /* skip val->shaderInt8 */
-    /* skip val->descriptorIndexing */
-    /* skip val->shaderInputAttachmentArrayDynamicIndexing */
-    /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
-    /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
-    /* skip val->shaderUniformBufferArrayNonUniformIndexing */
-    /* skip val->shaderSampledImageArrayNonUniformIndexing */
-    /* skip val->shaderStorageBufferArrayNonUniformIndexing */
-    /* skip val->shaderStorageImageArrayNonUniformIndexing */
-    /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
-    /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
-    /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
-    /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
-    /* skip val->descriptorBindingSampledImageUpdateAfterBind */
-    /* skip val->descriptorBindingStorageImageUpdateAfterBind */
-    /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
-    /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
-    /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
-    /* skip val->descriptorBindingUpdateUnusedWhilePending */
-    /* skip val->descriptorBindingPartiallyBound */
-    /* skip val->descriptorBindingVariableDescriptorCount */
-    /* skip val->runtimeDescriptorArray */
-    /* skip val->samplerFilterMinmax */
-    /* skip val->scalarBlockLayout */
-    /* skip val->imagelessFramebuffer */
-    /* skip val->uniformBufferStandardLayout */
-    /* skip val->shaderSubgroupExtendedTypes */
-    /* skip val->separateDepthStencilLayouts */
-    /* skip val->hostQueryReset */
-    /* skip val->timelineSemaphore */
-    /* skip val->bufferDeviceAddress */
-    /* skip val->bufferDeviceAddressCaptureReplay */
-    /* skip val->bufferDeviceAddressMultiDevice */
-    /* skip val->vulkanMemoryModel */
-    /* skip val->vulkanMemoryModelDeviceScope */
-    /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
-    /* skip val->shaderOutputViewportIndex */
-    /* skip val->shaderOutputLayer */
-    /* skip val->subgroupBroadcastDynamicId */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
-    vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceFeatures2 chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkPhysicalDeviceFeatures(&val->features);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceFeatures2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkPhysicalDeviceFeatures(enc, &val->features);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
-    vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceFeatures2_self(enc, val);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
-    VkStructureType stype;
-
-    if (!vn_decode_simple_pointer(dec))
-        return;
-
-    vn_decode_VkStructureType(dec, &stype);
-    while (true) {
-        assert(pnext);
-        if (pnext->sType == stype)
-            break;
-    }
-
-    switch ((int32_t)pnext->sType) {
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, (VkPhysicalDeviceMultiviewFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, (VkPhysicalDevice16BitStorageFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, (VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, (VkPhysicalDeviceHostQueryResetFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, (VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, (VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, (VkPhysicalDevice8BitStorageFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, (VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, (VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, (VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, (VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, (VkPhysicalDeviceVulkan11Features *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
-        vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, (VkPhysicalDeviceVulkan12Features *)pnext);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkPhysicalDeviceFeatures(dec, &val->features);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceFeatures2_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial((const VkPhysicalDeviceMultiviewFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial((const VkPhysicalDevice16BitStorageFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial((const VkPhysicalDevice8BitStorageFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial((const VkPhysicalDeviceVulkan11Features *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial((const VkPhysicalDeviceVulkan12Features *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkPhysicalDeviceFeatures_partial(&val->features);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkPhysicalDeviceFeatures_partial(enc, &val->features);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
-    vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceFeatures2_self_partial(enc, val);
-}
-
-/* struct VkDeviceGroupDeviceCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
-    if (val->pPhysicalDevices) {
-        size += vn_sizeof_array_size(val->physicalDeviceCount);
-        for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
-            size += vn_sizeof_VkPhysicalDevice(&val->pPhysicalDevices[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->physicalDeviceCount);
-    if (val->pPhysicalDevices) {
-        vn_encode_array_size(enc, val->physicalDeviceCount);
-        for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
-            vn_encode_VkPhysicalDevice(enc, &val->pPhysicalDevices[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO });
-    vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, val);
-}
-
-/* struct VkDeviceCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkDeviceCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceFeatures2_self((const VkPhysicalDeviceFeatures2 *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self((const VkDeviceGroupDeviceCreateInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->queueCreateInfoCount);
-    if (val->pQueueCreateInfos) {
-        size += vn_sizeof_array_size(val->queueCreateInfoCount);
-        for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
-            size += vn_sizeof_VkDeviceQueueCreateInfo(&val->pQueueCreateInfos[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->enabledLayerCount);
-    if (val->ppEnabledLayerNames) {
-        size += vn_sizeof_array_size(val->enabledLayerCount);
-        for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
-            const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
-            size += vn_sizeof_array_size(string_size);
-            size += vn_sizeof_blob_array(val->ppEnabledLayerNames[i], string_size);
-        }
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->enabledExtensionCount);
-    if (val->ppEnabledExtensionNames) {
-        size += vn_sizeof_array_size(val->enabledExtensionCount);
-        for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
-            const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
-            size += vn_sizeof_array_size(string_size);
-            size += vn_sizeof_blob_array(val->ppEnabledExtensionNames[i], string_size);
-        }
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_simple_pointer(val->pEnabledFeatures);
-    if (val->pEnabledFeatures)
-        size += vn_sizeof_VkPhysicalDeviceFeatures(val->pEnabledFeatures);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDeviceCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDeviceCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceFeatures2_self(enc, (const VkPhysicalDeviceFeatures2 *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, (const VkDeviceGroupDeviceCreateInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->queueCreateInfoCount);
-    if (val->pQueueCreateInfos) {
-        vn_encode_array_size(enc, val->queueCreateInfoCount);
-        for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
-            vn_encode_VkDeviceQueueCreateInfo(enc, &val->pQueueCreateInfos[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->enabledLayerCount);
-    if (val->ppEnabledLayerNames) {
-        vn_encode_array_size(enc, val->enabledLayerCount);
-        for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
-            const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
-            vn_encode_array_size(enc, string_size);
-            vn_encode_blob_array(enc, val->ppEnabledLayerNames[i], string_size);
-        }
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->enabledExtensionCount);
-    if (val->ppEnabledExtensionNames) {
-        vn_encode_array_size(enc, val->enabledExtensionCount);
-        for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
-            const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
-            vn_encode_array_size(enc, string_size);
-            vn_encode_blob_array(enc, val->ppEnabledExtensionNames[i], string_size);
-        }
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (vn_encode_simple_pointer(enc, val->pEnabledFeatures))
-        vn_encode_VkPhysicalDeviceFeatures(enc, val->pEnabledFeatures);
-}
-
-static inline void
-vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO });
-    vn_encode_VkDeviceCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkDeviceCreateInfo_self(enc, val);
-}
-
-/* struct VkInstanceCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkInstanceCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkInstanceCreateInfo_self(const VkInstanceCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_simple_pointer(val->pApplicationInfo);
-    if (val->pApplicationInfo)
-        size += vn_sizeof_VkApplicationInfo(val->pApplicationInfo);
-    size += vn_sizeof_uint32_t(&val->enabledLayerCount);
-    if (val->ppEnabledLayerNames) {
-        size += vn_sizeof_array_size(val->enabledLayerCount);
-        for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
-            const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
-            size += vn_sizeof_array_size(string_size);
-            size += vn_sizeof_blob_array(val->ppEnabledLayerNames[i], string_size);
-        }
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->enabledExtensionCount);
-    if (val->ppEnabledExtensionNames) {
-        size += vn_sizeof_array_size(val->enabledExtensionCount);
-        for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
-            const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
-            size += vn_sizeof_array_size(string_size);
-            size += vn_sizeof_blob_array(val->ppEnabledExtensionNames[i], string_size);
-        }
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkInstanceCreateInfo(const VkInstanceCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkInstanceCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkInstanceCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkInstanceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkInstanceCreateInfo_self(struct vn_cs_encoder *enc, const VkInstanceCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    if (vn_encode_simple_pointer(enc, val->pApplicationInfo))
-        vn_encode_VkApplicationInfo(enc, val->pApplicationInfo);
-    vn_encode_uint32_t(enc, &val->enabledLayerCount);
-    if (val->ppEnabledLayerNames) {
-        vn_encode_array_size(enc, val->enabledLayerCount);
-        for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
-            const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
-            vn_encode_array_size(enc, string_size);
-            vn_encode_blob_array(enc, val->ppEnabledLayerNames[i], string_size);
-        }
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->enabledExtensionCount);
-    if (val->ppEnabledExtensionNames) {
-        vn_encode_array_size(enc, val->enabledExtensionCount);
-        for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
-            const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
-            vn_encode_array_size(enc, string_size);
-            vn_encode_blob_array(enc, val->ppEnabledExtensionNames[i], string_size);
-        }
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkInstanceCreateInfo(struct vn_cs_encoder *enc, const VkInstanceCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO });
-    vn_encode_VkInstanceCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkInstanceCreateInfo_self(enc, val);
-}
-
-/* struct VkQueueFamilyProperties */
-
-static inline size_t
-vn_sizeof_VkQueueFamilyProperties(const VkQueueFamilyProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->queueFlags);
-    size += vn_sizeof_uint32_t(&val->queueCount);
-    size += vn_sizeof_uint32_t(&val->timestampValidBits);
-    size += vn_sizeof_VkExtent3D(&val->minImageTransferGranularity);
-    return size;
-}
-
-static inline void
-vn_decode_VkQueueFamilyProperties(struct vn_cs_decoder *dec, VkQueueFamilyProperties *val)
-{
-    vn_decode_VkFlags(dec, &val->queueFlags);
-    vn_decode_uint32_t(dec, &val->queueCount);
-    vn_decode_uint32_t(dec, &val->timestampValidBits);
-    vn_decode_VkExtent3D(dec, &val->minImageTransferGranularity);
-}
-
-static inline size_t
-vn_sizeof_VkQueueFamilyProperties_partial(const VkQueueFamilyProperties *val)
-{
-    size_t size = 0;
-    /* skip val->queueFlags */
-    /* skip val->queueCount */
-    /* skip val->timestampValidBits */
-    size += vn_sizeof_VkExtent3D_partial(&val->minImageTransferGranularity);
-    return size;
-}
-
-static inline void
-vn_encode_VkQueueFamilyProperties_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties *val)
-{
-    /* skip val->queueFlags */
-    /* skip val->queueCount */
-    /* skip val->timestampValidBits */
-    vn_encode_VkExtent3D_partial(enc, &val->minImageTransferGranularity);
-}
-
-/* struct VkMemoryType */
-
-static inline size_t
-vn_sizeof_VkMemoryType(const VkMemoryType *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->propertyFlags);
-    size += vn_sizeof_uint32_t(&val->heapIndex);
-    return size;
-}
-
-static inline void
-vn_decode_VkMemoryType(struct vn_cs_decoder *dec, VkMemoryType *val)
-{
-    vn_decode_VkFlags(dec, &val->propertyFlags);
-    vn_decode_uint32_t(dec, &val->heapIndex);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryType_partial(const VkMemoryType *val)
-{
-    size_t size = 0;
-    /* skip val->propertyFlags */
-    /* skip val->heapIndex */
-    return size;
-}
-
-static inline void
-vn_encode_VkMemoryType_partial(struct vn_cs_encoder *enc, const VkMemoryType *val)
-{
-    /* skip val->propertyFlags */
-    /* skip val->heapIndex */
-}
-
-/* struct VkMemoryHeap */
-
-static inline size_t
-vn_sizeof_VkMemoryHeap(const VkMemoryHeap *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkDeviceSize(&val->size);
-    size += vn_sizeof_VkFlags(&val->flags);
-    return size;
-}
-
-static inline void
-vn_decode_VkMemoryHeap(struct vn_cs_decoder *dec, VkMemoryHeap *val)
-{
-    vn_decode_VkDeviceSize(dec, &val->size);
-    vn_decode_VkFlags(dec, &val->flags);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryHeap_partial(const VkMemoryHeap *val)
-{
-    size_t size = 0;
-    /* skip val->size */
-    /* skip val->flags */
-    return size;
-}
-
-static inline void
-vn_encode_VkMemoryHeap_partial(struct vn_cs_encoder *enc, const VkMemoryHeap *val)
-{
-    /* skip val->size */
-    /* skip val->flags */
-}
-
-/* struct VkPhysicalDeviceMemoryProperties */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->memoryTypeCount);
-    size += vn_sizeof_array_size(VK_MAX_MEMORY_TYPES);
-    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
-        size += vn_sizeof_VkMemoryType(&val->memoryTypes[i]);
-    size += vn_sizeof_uint32_t(&val->memoryHeapCount);
-    size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS);
-    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
-        size += vn_sizeof_VkMemoryHeap(&val->memoryHeaps[i]);
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties *val)
-{
-    vn_decode_uint32_t(dec, &val->memoryTypeCount);
-    {
-        vn_decode_array_size(dec, VK_MAX_MEMORY_TYPES);
-        for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
-            vn_decode_VkMemoryType(dec, &val->memoryTypes[i]);
-    }
-    vn_decode_uint32_t(dec, &val->memoryHeapCount);
-    {
-        vn_decode_array_size(dec, VK_MAX_MEMORY_HEAPS);
-        for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
-            vn_decode_VkMemoryHeap(dec, &val->memoryHeaps[i]);
-    }
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(const VkPhysicalDeviceMemoryProperties *val)
-{
-    size_t size = 0;
-    /* skip val->memoryTypeCount */
-    size += vn_sizeof_array_size(VK_MAX_MEMORY_TYPES);
-    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
-        size += vn_sizeof_VkMemoryType_partial(&val->memoryTypes[i]);
-    /* skip val->memoryHeapCount */
-    size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS);
-    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
-        size += vn_sizeof_VkMemoryHeap_partial(&val->memoryHeaps[i]);
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties *val)
-{
-    /* skip val->memoryTypeCount */
-    vn_encode_array_size(enc, VK_MAX_MEMORY_TYPES);
-    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
-        vn_encode_VkMemoryType_partial(enc, &val->memoryTypes[i]);
-    /* skip val->memoryHeapCount */
-    vn_encode_array_size(enc, VK_MAX_MEMORY_HEAPS);
-    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
-        vn_encode_VkMemoryHeap_partial(enc, &val->memoryHeaps[i]);
-}
-
-/* struct VkExportMemoryAllocateInfo chain */
-
-static inline size_t
-vn_sizeof_VkExportMemoryAllocateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExportMemoryAllocateInfo_self(const VkExportMemoryAllocateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->handleTypes);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExportMemoryAllocateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkExportMemoryAllocateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkExportMemoryAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkExportMemoryAllocateInfo_self(struct vn_cs_encoder *enc, const VkExportMemoryAllocateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->handleTypes);
-}
-
-static inline void
-vn_encode_VkExportMemoryAllocateInfo(struct vn_cs_encoder *enc, const VkExportMemoryAllocateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO });
-    vn_encode_VkExportMemoryAllocateInfo_pnext(enc, val->pNext);
-    vn_encode_VkExportMemoryAllocateInfo_self(enc, val);
-}
-
-/* struct VkMemoryAllocateFlagsInfo chain */
-
-static inline size_t
-vn_sizeof_VkMemoryAllocateFlagsInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryAllocateFlagsInfo_self(const VkMemoryAllocateFlagsInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->deviceMask);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkMemoryAllocateFlagsInfo_pnext(val->pNext);
-    size += vn_sizeof_VkMemoryAllocateFlagsInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkMemoryAllocateFlagsInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkMemoryAllocateFlagsInfo_self(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagsInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->deviceMask);
-}
-
-static inline void
-vn_encode_VkMemoryAllocateFlagsInfo(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagsInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO });
-    vn_encode_VkMemoryAllocateFlagsInfo_pnext(enc, val->pNext);
-    vn_encode_VkMemoryAllocateFlagsInfo_self(enc, val);
-}
-
-/* struct VkMemoryDedicatedAllocateInfo chain */
-
-static inline size_t
-vn_sizeof_VkMemoryDedicatedAllocateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryDedicatedAllocateInfo_self(const VkMemoryDedicatedAllocateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkImage(&val->image);
-    size += vn_sizeof_VkBuffer(&val->buffer);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkMemoryDedicatedAllocateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkMemoryDedicatedAllocateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkMemoryDedicatedAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkMemoryDedicatedAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryDedicatedAllocateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkImage(enc, &val->image);
-    vn_encode_VkBuffer(enc, &val->buffer);
-}
-
-static inline void
-vn_encode_VkMemoryDedicatedAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryDedicatedAllocateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO });
-    vn_encode_VkMemoryDedicatedAllocateInfo_pnext(enc, val->pNext);
-    vn_encode_VkMemoryDedicatedAllocateInfo_self(enc, val);
-}
-
-/* struct VkMemoryOpaqueCaptureAddressAllocateInfo chain */
-
-static inline size_t
-vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self(const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint64_t(&val->opaqueCaptureAddress);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint64_t(enc, &val->opaqueCaptureAddress);
-}
-
-static inline void
-vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO });
-    vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(enc, val->pNext);
-    vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(enc, val);
-}
-
-/* struct VkMemoryAllocateInfo chain */
-
-static inline size_t
-vn_sizeof_VkMemoryAllocateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkExportMemoryAllocateInfo_self((const VkExportMemoryAllocateInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkMemoryAllocateFlagsInfo_self((const VkMemoryAllocateFlagsInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkMemoryDedicatedAllocateInfo_self((const VkMemoryDedicatedAllocateInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self((const VkMemoryOpaqueCaptureAddressAllocateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryAllocateInfo_self(const VkMemoryAllocateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkDeviceSize(&val->allocationSize);
-    size += vn_sizeof_uint32_t(&val->memoryTypeIndex);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkMemoryAllocateInfo(const VkMemoryAllocateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkMemoryAllocateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkMemoryAllocateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkMemoryAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkExportMemoryAllocateInfo_self(enc, (const VkExportMemoryAllocateInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkMemoryAllocateFlagsInfo_self(enc, (const VkMemoryAllocateFlagsInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkMemoryDedicatedAllocateInfo_self(enc, (const VkMemoryDedicatedAllocateInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(enc, (const VkMemoryOpaqueCaptureAddressAllocateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkMemoryAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryAllocateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkDeviceSize(enc, &val->allocationSize);
-    vn_encode_uint32_t(enc, &val->memoryTypeIndex);
-}
-
-static inline void
-vn_encode_VkMemoryAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryAllocateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO });
-    vn_encode_VkMemoryAllocateInfo_pnext(enc, val->pNext);
-    vn_encode_VkMemoryAllocateInfo_self(enc, val);
-}
-
-/* struct VkMemoryRequirements */
-
-static inline size_t
-vn_sizeof_VkMemoryRequirements(const VkMemoryRequirements *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkDeviceSize(&val->size);
-    size += vn_sizeof_VkDeviceSize(&val->alignment);
-    size += vn_sizeof_uint32_t(&val->memoryTypeBits);
-    return size;
-}
-
-static inline void
-vn_decode_VkMemoryRequirements(struct vn_cs_decoder *dec, VkMemoryRequirements *val)
-{
-    vn_decode_VkDeviceSize(dec, &val->size);
-    vn_decode_VkDeviceSize(dec, &val->alignment);
-    vn_decode_uint32_t(dec, &val->memoryTypeBits);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryRequirements_partial(const VkMemoryRequirements *val)
-{
-    size_t size = 0;
-    /* skip val->size */
-    /* skip val->alignment */
-    /* skip val->memoryTypeBits */
-    return size;
-}
-
-static inline void
-vn_encode_VkMemoryRequirements_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements *val)
-{
-    /* skip val->size */
-    /* skip val->alignment */
-    /* skip val->memoryTypeBits */
-}
-
-/* struct VkSparseImageFormatProperties */
-
-static inline size_t
-vn_sizeof_VkSparseImageFormatProperties(const VkSparseImageFormatProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->aspectMask);
-    size += vn_sizeof_VkExtent3D(&val->imageGranularity);
-    size += vn_sizeof_VkFlags(&val->flags);
-    return size;
-}
-
-static inline void
-vn_decode_VkSparseImageFormatProperties(struct vn_cs_decoder *dec, VkSparseImageFormatProperties *val)
-{
-    vn_decode_VkFlags(dec, &val->aspectMask);
-    vn_decode_VkExtent3D(dec, &val->imageGranularity);
-    vn_decode_VkFlags(dec, &val->flags);
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageFormatProperties_partial(const VkSparseImageFormatProperties *val)
-{
-    size_t size = 0;
-    /* skip val->aspectMask */
-    size += vn_sizeof_VkExtent3D_partial(&val->imageGranularity);
-    /* skip val->flags */
-    return size;
-}
-
-static inline void
-vn_encode_VkSparseImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties *val)
-{
-    /* skip val->aspectMask */
-    vn_encode_VkExtent3D_partial(enc, &val->imageGranularity);
-    /* skip val->flags */
-}
-
-/* struct VkSparseImageMemoryRequirements */
-
-static inline size_t
-vn_sizeof_VkSparseImageMemoryRequirements(const VkSparseImageMemoryRequirements *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkSparseImageFormatProperties(&val->formatProperties);
-    size += vn_sizeof_uint32_t(&val->imageMipTailFirstLod);
-    size += vn_sizeof_VkDeviceSize(&val->imageMipTailSize);
-    size += vn_sizeof_VkDeviceSize(&val->imageMipTailOffset);
-    size += vn_sizeof_VkDeviceSize(&val->imageMipTailStride);
-    return size;
-}
-
-static inline void
-vn_decode_VkSparseImageMemoryRequirements(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements *val)
-{
-    vn_decode_VkSparseImageFormatProperties(dec, &val->formatProperties);
-    vn_decode_uint32_t(dec, &val->imageMipTailFirstLod);
-    vn_decode_VkDeviceSize(dec, &val->imageMipTailSize);
-    vn_decode_VkDeviceSize(dec, &val->imageMipTailOffset);
-    vn_decode_VkDeviceSize(dec, &val->imageMipTailStride);
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageMemoryRequirements_partial(const VkSparseImageMemoryRequirements *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->formatProperties);
-    /* skip val->imageMipTailFirstLod */
-    /* skip val->imageMipTailSize */
-    /* skip val->imageMipTailOffset */
-    /* skip val->imageMipTailStride */
-    return size;
-}
-
-static inline void
-vn_encode_VkSparseImageMemoryRequirements_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements *val)
-{
-    vn_encode_VkSparseImageFormatProperties_partial(enc, &val->formatProperties);
-    /* skip val->imageMipTailFirstLod */
-    /* skip val->imageMipTailSize */
-    /* skip val->imageMipTailOffset */
-    /* skip val->imageMipTailStride */
-}
-
-/* struct VkMappedMemoryRange chain */
-
-static inline size_t
-vn_sizeof_VkMappedMemoryRange_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkMappedMemoryRange_self(const VkMappedMemoryRange *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkDeviceMemory(&val->memory);
-    size += vn_sizeof_VkDeviceSize(&val->offset);
-    size += vn_sizeof_VkDeviceSize(&val->size);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkMappedMemoryRange(const VkMappedMemoryRange *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkMappedMemoryRange_pnext(val->pNext);
-    size += vn_sizeof_VkMappedMemoryRange_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkMappedMemoryRange_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkMappedMemoryRange_self(struct vn_cs_encoder *enc, const VkMappedMemoryRange *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkDeviceMemory(enc, &val->memory);
-    vn_encode_VkDeviceSize(enc, &val->offset);
-    vn_encode_VkDeviceSize(enc, &val->size);
-}
-
-static inline void
-vn_encode_VkMappedMemoryRange(struct vn_cs_encoder *enc, const VkMappedMemoryRange *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE });
-    vn_encode_VkMappedMemoryRange_pnext(enc, val->pNext);
-    vn_encode_VkMappedMemoryRange_self(enc, val);
-}
-
-static inline void
-vn_decode_VkMappedMemoryRange_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkMappedMemoryRange_self(struct vn_cs_decoder *dec, VkMappedMemoryRange *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkDeviceMemory(dec, &val->memory);
-    vn_decode_VkDeviceSize(dec, &val->offset);
-    vn_decode_VkDeviceSize(dec, &val->size);
-}
-
-static inline void
-vn_decode_VkMappedMemoryRange(struct vn_cs_decoder *dec, VkMappedMemoryRange *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE);
-
-    assert(val->sType == stype);
-    vn_decode_VkMappedMemoryRange_pnext(dec, val->pNext);
-    vn_decode_VkMappedMemoryRange_self(dec, val);
-}
-
-/* struct VkFormatProperties */
-
-static inline size_t
-vn_sizeof_VkFormatProperties(const VkFormatProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->linearTilingFeatures);
-    size += vn_sizeof_VkFlags(&val->optimalTilingFeatures);
-    size += vn_sizeof_VkFlags(&val->bufferFeatures);
-    return size;
-}
-
-static inline void
-vn_decode_VkFormatProperties(struct vn_cs_decoder *dec, VkFormatProperties *val)
-{
-    vn_decode_VkFlags(dec, &val->linearTilingFeatures);
-    vn_decode_VkFlags(dec, &val->optimalTilingFeatures);
-    vn_decode_VkFlags(dec, &val->bufferFeatures);
-}
-
-static inline size_t
-vn_sizeof_VkFormatProperties_partial(const VkFormatProperties *val)
-{
-    size_t size = 0;
-    /* skip val->linearTilingFeatures */
-    /* skip val->optimalTilingFeatures */
-    /* skip val->bufferFeatures */
-    return size;
-}
-
-static inline void
-vn_encode_VkFormatProperties_partial(struct vn_cs_encoder *enc, const VkFormatProperties *val)
-{
-    /* skip val->linearTilingFeatures */
-    /* skip val->optimalTilingFeatures */
-    /* skip val->bufferFeatures */
-}
-
-/* struct VkImageFormatProperties */
-
-static inline size_t
-vn_sizeof_VkImageFormatProperties(const VkImageFormatProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkExtent3D(&val->maxExtent);
-    size += vn_sizeof_uint32_t(&val->maxMipLevels);
-    size += vn_sizeof_uint32_t(&val->maxArrayLayers);
-    size += vn_sizeof_VkFlags(&val->sampleCounts);
-    size += vn_sizeof_VkDeviceSize(&val->maxResourceSize);
-    return size;
-}
-
-static inline void
-vn_decode_VkImageFormatProperties(struct vn_cs_decoder *dec, VkImageFormatProperties *val)
-{
-    vn_decode_VkExtent3D(dec, &val->maxExtent);
-    vn_decode_uint32_t(dec, &val->maxMipLevels);
-    vn_decode_uint32_t(dec, &val->maxArrayLayers);
-    vn_decode_VkFlags(dec, &val->sampleCounts);
-    vn_decode_VkDeviceSize(dec, &val->maxResourceSize);
-}
-
-static inline size_t
-vn_sizeof_VkImageFormatProperties_partial(const VkImageFormatProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkExtent3D_partial(&val->maxExtent);
-    /* skip val->maxMipLevels */
-    /* skip val->maxArrayLayers */
-    /* skip val->sampleCounts */
-    /* skip val->maxResourceSize */
-    return size;
-}
-
-static inline void
-vn_encode_VkImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties *val)
-{
-    vn_encode_VkExtent3D_partial(enc, &val->maxExtent);
-    /* skip val->maxMipLevels */
-    /* skip val->maxArrayLayers */
-    /* skip val->sampleCounts */
-    /* skip val->maxResourceSize */
-}
-
-/* struct VkDescriptorBufferInfo */
-
-static inline size_t
-vn_sizeof_VkDescriptorBufferInfo(const VkDescriptorBufferInfo *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkBuffer(&val->buffer);
-    size += vn_sizeof_VkDeviceSize(&val->offset);
-    size += vn_sizeof_VkDeviceSize(&val->range);
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorBufferInfo(struct vn_cs_encoder *enc, const VkDescriptorBufferInfo *val)
-{
-    vn_encode_VkBuffer(enc, &val->buffer);
-    vn_encode_VkDeviceSize(enc, &val->offset);
-    vn_encode_VkDeviceSize(enc, &val->range);
-}
-
-/* struct VkDescriptorImageInfo */
-
-static inline size_t
-vn_sizeof_VkDescriptorImageInfo(const VkDescriptorImageInfo *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkSampler(&val->sampler);
-    size += vn_sizeof_VkImageView(&val->imageView);
-    size += vn_sizeof_VkImageLayout(&val->imageLayout);
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorImageInfo(struct vn_cs_encoder *enc, const VkDescriptorImageInfo *val)
-{
-    vn_encode_VkSampler(enc, &val->sampler);
-    vn_encode_VkImageView(enc, &val->imageView);
-    vn_encode_VkImageLayout(enc, &val->imageLayout);
-}
-
-/* struct VkWriteDescriptorSet chain */
-
-static inline size_t
-vn_sizeof_VkWriteDescriptorSet_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkWriteDescriptorSet_self(const VkWriteDescriptorSet *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkDescriptorSet(&val->dstSet);
-    size += vn_sizeof_uint32_t(&val->dstBinding);
-    size += vn_sizeof_uint32_t(&val->dstArrayElement);
-    size += vn_sizeof_uint32_t(&val->descriptorCount);
-    size += vn_sizeof_VkDescriptorType(&val->descriptorType);
-    if (val->pImageInfo) {
-        size += vn_sizeof_array_size(val->descriptorCount);
-        for (uint32_t i = 0; i < val->descriptorCount; i++)
-            size += vn_sizeof_VkDescriptorImageInfo(&val->pImageInfo[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    if (val->pBufferInfo) {
-        size += vn_sizeof_array_size(val->descriptorCount);
-        for (uint32_t i = 0; i < val->descriptorCount; i++)
-            size += vn_sizeof_VkDescriptorBufferInfo(&val->pBufferInfo[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    if (val->pTexelBufferView) {
-        size += vn_sizeof_array_size(val->descriptorCount);
-        for (uint32_t i = 0; i < val->descriptorCount; i++)
-            size += vn_sizeof_VkBufferView(&val->pTexelBufferView[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkWriteDescriptorSet(const VkWriteDescriptorSet *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkWriteDescriptorSet_pnext(val->pNext);
-    size += vn_sizeof_VkWriteDescriptorSet_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkWriteDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkWriteDescriptorSet_self(struct vn_cs_encoder *enc, const VkWriteDescriptorSet *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkDescriptorSet(enc, &val->dstSet);
-    vn_encode_uint32_t(enc, &val->dstBinding);
-    vn_encode_uint32_t(enc, &val->dstArrayElement);
-    vn_encode_uint32_t(enc, &val->descriptorCount);
-    vn_encode_VkDescriptorType(enc, &val->descriptorType);
-    if (val->pImageInfo) {
-        vn_encode_array_size(enc, val->descriptorCount);
-        for (uint32_t i = 0; i < val->descriptorCount; i++)
-            vn_encode_VkDescriptorImageInfo(enc, &val->pImageInfo[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (val->pBufferInfo) {
-        vn_encode_array_size(enc, val->descriptorCount);
-        for (uint32_t i = 0; i < val->descriptorCount; i++)
-            vn_encode_VkDescriptorBufferInfo(enc, &val->pBufferInfo[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (val->pTexelBufferView) {
-        vn_encode_array_size(enc, val->descriptorCount);
-        for (uint32_t i = 0; i < val->descriptorCount; i++)
-            vn_encode_VkBufferView(enc, &val->pTexelBufferView[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkWriteDescriptorSet(struct vn_cs_encoder *enc, const VkWriteDescriptorSet *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET });
-    vn_encode_VkWriteDescriptorSet_pnext(enc, val->pNext);
-    vn_encode_VkWriteDescriptorSet_self(enc, val);
-}
-
-/* struct VkCopyDescriptorSet chain */
-
-static inline size_t
-vn_sizeof_VkCopyDescriptorSet_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkCopyDescriptorSet_self(const VkCopyDescriptorSet *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkDescriptorSet(&val->srcSet);
-    size += vn_sizeof_uint32_t(&val->srcBinding);
-    size += vn_sizeof_uint32_t(&val->srcArrayElement);
-    size += vn_sizeof_VkDescriptorSet(&val->dstSet);
-    size += vn_sizeof_uint32_t(&val->dstBinding);
-    size += vn_sizeof_uint32_t(&val->dstArrayElement);
-    size += vn_sizeof_uint32_t(&val->descriptorCount);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkCopyDescriptorSet(const VkCopyDescriptorSet *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkCopyDescriptorSet_pnext(val->pNext);
-    size += vn_sizeof_VkCopyDescriptorSet_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkCopyDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkCopyDescriptorSet_self(struct vn_cs_encoder *enc, const VkCopyDescriptorSet *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkDescriptorSet(enc, &val->srcSet);
-    vn_encode_uint32_t(enc, &val->srcBinding);
-    vn_encode_uint32_t(enc, &val->srcArrayElement);
-    vn_encode_VkDescriptorSet(enc, &val->dstSet);
-    vn_encode_uint32_t(enc, &val->dstBinding);
-    vn_encode_uint32_t(enc, &val->dstArrayElement);
-    vn_encode_uint32_t(enc, &val->descriptorCount);
-}
-
-static inline void
-vn_encode_VkCopyDescriptorSet(struct vn_cs_encoder *enc, const VkCopyDescriptorSet *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET });
-    vn_encode_VkCopyDescriptorSet_pnext(enc, val->pNext);
-    vn_encode_VkCopyDescriptorSet_self(enc, val);
-}
-
-/* struct VkExternalMemoryBufferCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkExternalMemoryBufferCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExternalMemoryBufferCreateInfo_self(const VkExternalMemoryBufferCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->handleTypes);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExternalMemoryBufferCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkExternalMemoryBufferCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkExternalMemoryBufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkExternalMemoryBufferCreateInfo_self(struct vn_cs_encoder *enc, const VkExternalMemoryBufferCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->handleTypes);
-}
-
-static inline void
-vn_encode_VkExternalMemoryBufferCreateInfo(struct vn_cs_encoder *enc, const VkExternalMemoryBufferCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO });
-    vn_encode_VkExternalMemoryBufferCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkExternalMemoryBufferCreateInfo_self(enc, val);
-}
-
-/* struct VkBufferOpaqueCaptureAddressCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_self(const VkBufferOpaqueCaptureAddressCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint64_t(&val->opaqueCaptureAddress);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferOpaqueCaptureAddressCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint64_t(enc, &val->opaqueCaptureAddress);
-}
-
-static inline void
-vn_encode_VkBufferOpaqueCaptureAddressCreateInfo(struct vn_cs_encoder *enc, const VkBufferOpaqueCaptureAddressCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO });
-    vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(enc, val);
-}
-
-/* struct VkBufferCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkBufferCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkBufferCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkExternalMemoryBufferCreateInfo_self((const VkExternalMemoryBufferCreateInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkBufferCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_self((const VkBufferOpaqueCaptureAddressCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBufferCreateInfo_self(const VkBufferCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkDeviceSize(&val->size);
-    size += vn_sizeof_VkFlags(&val->usage);
-    size += vn_sizeof_VkSharingMode(&val->sharingMode);
-    size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
-    if (val->pQueueFamilyIndices) {
-        size += vn_sizeof_array_size(val->queueFamilyIndexCount);
-        size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBufferCreateInfo(const VkBufferCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBufferCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkBufferCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkBufferCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkExternalMemoryBufferCreateInfo_self(enc, (const VkExternalMemoryBufferCreateInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkBufferCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(enc, (const VkBufferOpaqueCaptureAddressCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBufferCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkDeviceSize(enc, &val->size);
-    vn_encode_VkFlags(enc, &val->usage);
-    vn_encode_VkSharingMode(enc, &val->sharingMode);
-    vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
-    if (val->pQueueFamilyIndices) {
-        vn_encode_array_size(enc, val->queueFamilyIndexCount);
-        vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkBufferCreateInfo(struct vn_cs_encoder *enc, const VkBufferCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO });
-    vn_encode_VkBufferCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkBufferCreateInfo_self(enc, val);
-}
-
-/* struct VkBufferViewCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkBufferViewCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBufferViewCreateInfo_self(const VkBufferViewCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkBuffer(&val->buffer);
-    size += vn_sizeof_VkFormat(&val->format);
-    size += vn_sizeof_VkDeviceSize(&val->offset);
-    size += vn_sizeof_VkDeviceSize(&val->range);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBufferViewCreateInfo(const VkBufferViewCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBufferViewCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkBufferViewCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBufferViewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBufferViewCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferViewCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkBuffer(enc, &val->buffer);
-    vn_encode_VkFormat(enc, &val->format);
-    vn_encode_VkDeviceSize(enc, &val->offset);
-    vn_encode_VkDeviceSize(enc, &val->range);
-}
-
-static inline void
-vn_encode_VkBufferViewCreateInfo(struct vn_cs_encoder *enc, const VkBufferViewCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO });
-    vn_encode_VkBufferViewCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkBufferViewCreateInfo_self(enc, val);
-}
-
-/* struct VkImageSubresource */
-
-static inline size_t
-vn_sizeof_VkImageSubresource(const VkImageSubresource *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->aspectMask);
-    size += vn_sizeof_uint32_t(&val->mipLevel);
-    size += vn_sizeof_uint32_t(&val->arrayLayer);
-    return size;
-}
-
-static inline void
-vn_encode_VkImageSubresource(struct vn_cs_encoder *enc, const VkImageSubresource *val)
-{
-    vn_encode_VkFlags(enc, &val->aspectMask);
-    vn_encode_uint32_t(enc, &val->mipLevel);
-    vn_encode_uint32_t(enc, &val->arrayLayer);
-}
-
-/* struct VkImageSubresourceLayers */
-
-static inline size_t
-vn_sizeof_VkImageSubresourceLayers(const VkImageSubresourceLayers *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->aspectMask);
-    size += vn_sizeof_uint32_t(&val->mipLevel);
-    size += vn_sizeof_uint32_t(&val->baseArrayLayer);
-    size += vn_sizeof_uint32_t(&val->layerCount);
-    return size;
-}
-
-static inline void
-vn_encode_VkImageSubresourceLayers(struct vn_cs_encoder *enc, const VkImageSubresourceLayers *val)
-{
-    vn_encode_VkFlags(enc, &val->aspectMask);
-    vn_encode_uint32_t(enc, &val->mipLevel);
-    vn_encode_uint32_t(enc, &val->baseArrayLayer);
-    vn_encode_uint32_t(enc, &val->layerCount);
-}
-
-/* struct VkImageSubresourceRange */
-
-static inline size_t
-vn_sizeof_VkImageSubresourceRange(const VkImageSubresourceRange *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->aspectMask);
-    size += vn_sizeof_uint32_t(&val->baseMipLevel);
-    size += vn_sizeof_uint32_t(&val->levelCount);
-    size += vn_sizeof_uint32_t(&val->baseArrayLayer);
-    size += vn_sizeof_uint32_t(&val->layerCount);
-    return size;
-}
-
-static inline void
-vn_encode_VkImageSubresourceRange(struct vn_cs_encoder *enc, const VkImageSubresourceRange *val)
-{
-    vn_encode_VkFlags(enc, &val->aspectMask);
-    vn_encode_uint32_t(enc, &val->baseMipLevel);
-    vn_encode_uint32_t(enc, &val->levelCount);
-    vn_encode_uint32_t(enc, &val->baseArrayLayer);
-    vn_encode_uint32_t(enc, &val->layerCount);
-}
-
-/* struct VkMemoryBarrier chain */
-
-static inline size_t
-vn_sizeof_VkMemoryBarrier_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryBarrier_self(const VkMemoryBarrier *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->srcAccessMask);
-    size += vn_sizeof_VkFlags(&val->dstAccessMask);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkMemoryBarrier(const VkMemoryBarrier *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkMemoryBarrier_pnext(val->pNext);
-    size += vn_sizeof_VkMemoryBarrier_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkMemoryBarrier_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkMemoryBarrier_self(struct vn_cs_encoder *enc, const VkMemoryBarrier *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->srcAccessMask);
-    vn_encode_VkFlags(enc, &val->dstAccessMask);
-}
-
-static inline void
-vn_encode_VkMemoryBarrier(struct vn_cs_encoder *enc, const VkMemoryBarrier *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_BARRIER);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_BARRIER });
-    vn_encode_VkMemoryBarrier_pnext(enc, val->pNext);
-    vn_encode_VkMemoryBarrier_self(enc, val);
-}
-
-/* struct VkBufferMemoryBarrier chain */
-
-static inline size_t
-vn_sizeof_VkBufferMemoryBarrier_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBufferMemoryBarrier_self(const VkBufferMemoryBarrier *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->srcAccessMask);
-    size += vn_sizeof_VkFlags(&val->dstAccessMask);
-    size += vn_sizeof_uint32_t(&val->srcQueueFamilyIndex);
-    size += vn_sizeof_uint32_t(&val->dstQueueFamilyIndex);
-    size += vn_sizeof_VkBuffer(&val->buffer);
-    size += vn_sizeof_VkDeviceSize(&val->offset);
-    size += vn_sizeof_VkDeviceSize(&val->size);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBufferMemoryBarrier(const VkBufferMemoryBarrier *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBufferMemoryBarrier_pnext(val->pNext);
-    size += vn_sizeof_VkBufferMemoryBarrier_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBufferMemoryBarrier_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBufferMemoryBarrier_self(struct vn_cs_encoder *enc, const VkBufferMemoryBarrier *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->srcAccessMask);
-    vn_encode_VkFlags(enc, &val->dstAccessMask);
-    vn_encode_uint32_t(enc, &val->srcQueueFamilyIndex);
-    vn_encode_uint32_t(enc, &val->dstQueueFamilyIndex);
-    vn_encode_VkBuffer(enc, &val->buffer);
-    vn_encode_VkDeviceSize(enc, &val->offset);
-    vn_encode_VkDeviceSize(enc, &val->size);
-}
-
-static inline void
-vn_encode_VkBufferMemoryBarrier(struct vn_cs_encoder *enc, const VkBufferMemoryBarrier *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER });
-    vn_encode_VkBufferMemoryBarrier_pnext(enc, val->pNext);
-    vn_encode_VkBufferMemoryBarrier_self(enc, val);
-}
-
-/* struct VkImageMemoryBarrier chain */
-
-static inline size_t
-vn_sizeof_VkImageMemoryBarrier_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageMemoryBarrier_self(const VkImageMemoryBarrier *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->srcAccessMask);
-    size += vn_sizeof_VkFlags(&val->dstAccessMask);
-    size += vn_sizeof_VkImageLayout(&val->oldLayout);
-    size += vn_sizeof_VkImageLayout(&val->newLayout);
-    size += vn_sizeof_uint32_t(&val->srcQueueFamilyIndex);
-    size += vn_sizeof_uint32_t(&val->dstQueueFamilyIndex);
-    size += vn_sizeof_VkImage(&val->image);
-    size += vn_sizeof_VkImageSubresourceRange(&val->subresourceRange);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageMemoryBarrier(const VkImageMemoryBarrier *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageMemoryBarrier_pnext(val->pNext);
-    size += vn_sizeof_VkImageMemoryBarrier_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageMemoryBarrier_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageMemoryBarrier_self(struct vn_cs_encoder *enc, const VkImageMemoryBarrier *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->srcAccessMask);
-    vn_encode_VkFlags(enc, &val->dstAccessMask);
-    vn_encode_VkImageLayout(enc, &val->oldLayout);
-    vn_encode_VkImageLayout(enc, &val->newLayout);
-    vn_encode_uint32_t(enc, &val->srcQueueFamilyIndex);
-    vn_encode_uint32_t(enc, &val->dstQueueFamilyIndex);
-    vn_encode_VkImage(enc, &val->image);
-    vn_encode_VkImageSubresourceRange(enc, &val->subresourceRange);
-}
-
-static inline void
-vn_encode_VkImageMemoryBarrier(struct vn_cs_encoder *enc, const VkImageMemoryBarrier *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER });
-    vn_encode_VkImageMemoryBarrier_pnext(enc, val->pNext);
-    vn_encode_VkImageMemoryBarrier_self(enc, val);
-}
-
-/* struct VkExternalMemoryImageCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExternalMemoryImageCreateInfo_self(const VkExternalMemoryImageCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->handleTypes);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkExternalMemoryImageCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkExternalMemoryImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkExternalMemoryImageCreateInfo_self(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->handleTypes);
-}
-
-static inline void
-vn_encode_VkExternalMemoryImageCreateInfo(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO });
-    vn_encode_VkExternalMemoryImageCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkExternalMemoryImageCreateInfo_self(enc, val);
-}
-
-/* struct VkImageFormatListCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkImageFormatListCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageFormatListCreateInfo_self(const VkImageFormatListCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->viewFormatCount);
-    if (val->pViewFormats) {
-        size += vn_sizeof_array_size(val->viewFormatCount);
-        size += vn_sizeof_VkFormat_array(val->pViewFormats, val->viewFormatCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageFormatListCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkImageFormatListCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageFormatListCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageFormatListCreateInfo_self(struct vn_cs_encoder *enc, const VkImageFormatListCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->viewFormatCount);
-    if (val->pViewFormats) {
-        vn_encode_array_size(enc, val->viewFormatCount);
-        vn_encode_VkFormat_array(enc, val->pViewFormats, val->viewFormatCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkImageFormatListCreateInfo(struct vn_cs_encoder *enc, const VkImageFormatListCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO });
-    vn_encode_VkImageFormatListCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkImageFormatListCreateInfo_self(enc, val);
-}
-
-/* struct VkImageDrmFormatModifierListCreateInfoEXT chain */
-
-static inline size_t
-vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(const VkImageDrmFormatModifierListCreateInfoEXT *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
-    if (val->pDrmFormatModifiers) {
-        size += vn_sizeof_array_size(val->drmFormatModifierCount);
-        size += vn_sizeof_uint64_t_array(val->pDrmFormatModifiers, val->drmFormatModifierCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(val->pNext);
-    size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->drmFormatModifierCount);
-    if (val->pDrmFormatModifiers) {
-        vn_encode_array_size(enc, val->drmFormatModifierCount);
-        vn_encode_uint64_t_array(enc, val->pDrmFormatModifiers, val->drmFormatModifierCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT });
-    vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(enc, val->pNext);
-    vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, val);
-}
-
-/* struct VkSubresourceLayout */
-
-static inline size_t
-vn_sizeof_VkSubresourceLayout(const VkSubresourceLayout *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkDeviceSize(&val->offset);
-    size += vn_sizeof_VkDeviceSize(&val->size);
-    size += vn_sizeof_VkDeviceSize(&val->rowPitch);
-    size += vn_sizeof_VkDeviceSize(&val->arrayPitch);
-    size += vn_sizeof_VkDeviceSize(&val->depthPitch);
-    return size;
-}
-
-static inline void
-vn_encode_VkSubresourceLayout(struct vn_cs_encoder *enc, const VkSubresourceLayout *val)
-{
-    vn_encode_VkDeviceSize(enc, &val->offset);
-    vn_encode_VkDeviceSize(enc, &val->size);
-    vn_encode_VkDeviceSize(enc, &val->rowPitch);
-    vn_encode_VkDeviceSize(enc, &val->arrayPitch);
-    vn_encode_VkDeviceSize(enc, &val->depthPitch);
-}
-
-static inline void
-vn_decode_VkSubresourceLayout(struct vn_cs_decoder *dec, VkSubresourceLayout *val)
-{
-    vn_decode_VkDeviceSize(dec, &val->offset);
-    vn_decode_VkDeviceSize(dec, &val->size);
-    vn_decode_VkDeviceSize(dec, &val->rowPitch);
-    vn_decode_VkDeviceSize(dec, &val->arrayPitch);
-    vn_decode_VkDeviceSize(dec, &val->depthPitch);
-}
-
-static inline size_t
-vn_sizeof_VkSubresourceLayout_partial(const VkSubresourceLayout *val)
-{
-    size_t size = 0;
-    /* skip val->offset */
-    /* skip val->size */
-    /* skip val->rowPitch */
-    /* skip val->arrayPitch */
-    /* skip val->depthPitch */
-    return size;
-}
-
-static inline void
-vn_encode_VkSubresourceLayout_partial(struct vn_cs_encoder *enc, const VkSubresourceLayout *val)
-{
-    /* skip val->offset */
-    /* skip val->size */
-    /* skip val->rowPitch */
-    /* skip val->arrayPitch */
-    /* skip val->depthPitch */
-}
-
-/* struct VkImageDrmFormatModifierExplicitCreateInfoEXT chain */
-
-static inline size_t
-vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint64_t(&val->drmFormatModifier);
-    size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
-    if (val->pPlaneLayouts) {
-        size += vn_sizeof_array_size(val->drmFormatModifierPlaneCount);
-        for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++)
-            size += vn_sizeof_VkSubresourceLayout(&val->pPlaneLayouts[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(val->pNext);
-    size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint64_t(enc, &val->drmFormatModifier);
-    vn_encode_uint32_t(enc, &val->drmFormatModifierPlaneCount);
-    if (val->pPlaneLayouts) {
-        vn_encode_array_size(enc, val->drmFormatModifierPlaneCount);
-        for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++)
-            vn_encode_VkSubresourceLayout(enc, &val->pPlaneLayouts[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT });
-    vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(enc, val->pNext);
-    vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, val);
-}
-
-/* struct VkImageStencilUsageCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkImageStencilUsageCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageStencilUsageCreateInfo_self(const VkImageStencilUsageCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->stencilUsage);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageStencilUsageCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkImageStencilUsageCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageStencilUsageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageStencilUsageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageStencilUsageCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->stencilUsage);
-}
-
-static inline void
-vn_encode_VkImageStencilUsageCreateInfo(struct vn_cs_encoder *enc, const VkImageStencilUsageCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO });
-    vn_encode_VkImageStencilUsageCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkImageStencilUsageCreateInfo_self(enc, val);
-}
-
-/* struct VkImageCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkImageCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkExternalMemoryImageCreateInfo_self((const VkExternalMemoryImageCreateInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self((const VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self((const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageCreateInfo_self(const VkImageCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkImageType(&val->imageType);
-    size += vn_sizeof_VkFormat(&val->format);
-    size += vn_sizeof_VkExtent3D(&val->extent);
-    size += vn_sizeof_uint32_t(&val->mipLevels);
-    size += vn_sizeof_uint32_t(&val->arrayLayers);
-    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
-    size += vn_sizeof_VkImageTiling(&val->tiling);
-    size += vn_sizeof_VkFlags(&val->usage);
-    size += vn_sizeof_VkSharingMode(&val->sharingMode);
-    size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
-    if (val->pQueueFamilyIndices) {
-        size += vn_sizeof_array_size(val->queueFamilyIndexCount);
-        size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_VkImageLayout(&val->initialLayout);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageCreateInfo(const VkImageCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkImageCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkExternalMemoryImageCreateInfo_self(enc, (const VkExternalMemoryImageCreateInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkImageType(enc, &val->imageType);
-    vn_encode_VkFormat(enc, &val->format);
-    vn_encode_VkExtent3D(enc, &val->extent);
-    vn_encode_uint32_t(enc, &val->mipLevels);
-    vn_encode_uint32_t(enc, &val->arrayLayers);
-    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
-    vn_encode_VkImageTiling(enc, &val->tiling);
-    vn_encode_VkFlags(enc, &val->usage);
-    vn_encode_VkSharingMode(enc, &val->sharingMode);
-    vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
-    if (val->pQueueFamilyIndices) {
-        vn_encode_array_size(enc, val->queueFamilyIndexCount);
-        vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_VkImageLayout(enc, &val->initialLayout);
-}
-
-static inline void
-vn_encode_VkImageCreateInfo(struct vn_cs_encoder *enc, const VkImageCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO });
-    vn_encode_VkImageCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkImageCreateInfo_self(enc, val);
-}
-
-/* struct VkImageViewUsageCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkImageViewUsageCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageViewUsageCreateInfo_self(const VkImageViewUsageCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->usage);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageViewUsageCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkImageViewUsageCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageViewUsageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageViewUsageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageViewUsageCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->usage);
-}
-
-static inline void
-vn_encode_VkImageViewUsageCreateInfo(struct vn_cs_encoder *enc, const VkImageViewUsageCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO });
-    vn_encode_VkImageViewUsageCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkImageViewUsageCreateInfo_self(enc, val);
-}
-
-/* struct VkSamplerYcbcrConversionInfo chain */
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionInfo_self(const VkSamplerYcbcrConversionInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkSamplerYcbcrConversion(&val->conversion);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSamplerYcbcrConversionInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSamplerYcbcrConversionInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSamplerYcbcrConversionInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSamplerYcbcrConversionInfo_self(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkSamplerYcbcrConversion(enc, &val->conversion);
-}
-
-static inline void
-vn_encode_VkSamplerYcbcrConversionInfo(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO });
-    vn_encode_VkSamplerYcbcrConversionInfo_pnext(enc, val->pNext);
-    vn_encode_VkSamplerYcbcrConversionInfo_self(enc, val);
-}
-
-/* struct VkImageViewCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkImageViewCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageViewCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkImageViewUsageCreateInfo_self((const VkImageViewUsageCreateInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageViewCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkSamplerYcbcrConversionInfo_self((const VkSamplerYcbcrConversionInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageViewCreateInfo_self(const VkImageViewCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkImage(&val->image);
-    size += vn_sizeof_VkImageViewType(&val->viewType);
-    size += vn_sizeof_VkFormat(&val->format);
-    size += vn_sizeof_VkComponentMapping(&val->components);
-    size += vn_sizeof_VkImageSubresourceRange(&val->subresourceRange);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageViewCreateInfo(const VkImageViewCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageViewCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkImageViewCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageViewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkImageViewCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkImageViewUsageCreateInfo_self(enc, (const VkImageViewUsageCreateInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkImageViewCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkSamplerYcbcrConversionInfo_self(enc, (const VkSamplerYcbcrConversionInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageViewCreateInfo_self(struct vn_cs_encoder *enc, const VkImageViewCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkImage(enc, &val->image);
-    vn_encode_VkImageViewType(enc, &val->viewType);
-    vn_encode_VkFormat(enc, &val->format);
-    vn_encode_VkComponentMapping(enc, &val->components);
-    vn_encode_VkImageSubresourceRange(enc, &val->subresourceRange);
-}
-
-static inline void
-vn_encode_VkImageViewCreateInfo(struct vn_cs_encoder *enc, const VkImageViewCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO });
-    vn_encode_VkImageViewCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkImageViewCreateInfo_self(enc, val);
-}
-
-/* struct VkBufferCopy */
-
-static inline size_t
-vn_sizeof_VkBufferCopy(const VkBufferCopy *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkDeviceSize(&val->srcOffset);
-    size += vn_sizeof_VkDeviceSize(&val->dstOffset);
-    size += vn_sizeof_VkDeviceSize(&val->size);
-    return size;
-}
-
-static inline void
-vn_encode_VkBufferCopy(struct vn_cs_encoder *enc, const VkBufferCopy *val)
-{
-    vn_encode_VkDeviceSize(enc, &val->srcOffset);
-    vn_encode_VkDeviceSize(enc, &val->dstOffset);
-    vn_encode_VkDeviceSize(enc, &val->size);
-}
-
-/* struct VkSparseMemoryBind */
-
-static inline size_t
-vn_sizeof_VkSparseMemoryBind(const VkSparseMemoryBind *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkDeviceSize(&val->resourceOffset);
-    size += vn_sizeof_VkDeviceSize(&val->size);
-    size += vn_sizeof_VkDeviceMemory(&val->memory);
-    size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
-    size += vn_sizeof_VkFlags(&val->flags);
-    return size;
-}
-
-static inline void
-vn_encode_VkSparseMemoryBind(struct vn_cs_encoder *enc, const VkSparseMemoryBind *val)
-{
-    vn_encode_VkDeviceSize(enc, &val->resourceOffset);
-    vn_encode_VkDeviceSize(enc, &val->size);
-    vn_encode_VkDeviceMemory(enc, &val->memory);
-    vn_encode_VkDeviceSize(enc, &val->memoryOffset);
-    vn_encode_VkFlags(enc, &val->flags);
-}
-
-/* struct VkSparseImageMemoryBind */
-
-static inline size_t
-vn_sizeof_VkSparseImageMemoryBind(const VkSparseImageMemoryBind *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkImageSubresource(&val->subresource);
-    size += vn_sizeof_VkOffset3D(&val->offset);
-    size += vn_sizeof_VkExtent3D(&val->extent);
-    size += vn_sizeof_VkDeviceMemory(&val->memory);
-    size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
-    size += vn_sizeof_VkFlags(&val->flags);
-    return size;
-}
-
-static inline void
-vn_encode_VkSparseImageMemoryBind(struct vn_cs_encoder *enc, const VkSparseImageMemoryBind *val)
-{
-    vn_encode_VkImageSubresource(enc, &val->subresource);
-    vn_encode_VkOffset3D(enc, &val->offset);
-    vn_encode_VkExtent3D(enc, &val->extent);
-    vn_encode_VkDeviceMemory(enc, &val->memory);
-    vn_encode_VkDeviceSize(enc, &val->memoryOffset);
-    vn_encode_VkFlags(enc, &val->flags);
-}
-
-/* struct VkSparseBufferMemoryBindInfo */
-
-static inline size_t
-vn_sizeof_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkBuffer(&val->buffer);
-    size += vn_sizeof_uint32_t(&val->bindCount);
-    if (val->pBinds) {
-        size += vn_sizeof_array_size(val->bindCount);
-        for (uint32_t i = 0; i < val->bindCount; i++)
-            size += vn_sizeof_VkSparseMemoryBind(&val->pBinds[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline void
-vn_encode_VkSparseBufferMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseBufferMemoryBindInfo *val)
-{
-    vn_encode_VkBuffer(enc, &val->buffer);
-    vn_encode_uint32_t(enc, &val->bindCount);
-    if (val->pBinds) {
-        vn_encode_array_size(enc, val->bindCount);
-        for (uint32_t i = 0; i < val->bindCount; i++)
-            vn_encode_VkSparseMemoryBind(enc, &val->pBinds[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-/* struct VkSparseImageOpaqueMemoryBindInfo */
-
-static inline size_t
-vn_sizeof_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkImage(&val->image);
-    size += vn_sizeof_uint32_t(&val->bindCount);
-    if (val->pBinds) {
-        size += vn_sizeof_array_size(val->bindCount);
-        for (uint32_t i = 0; i < val->bindCount; i++)
-            size += vn_sizeof_VkSparseMemoryBind(&val->pBinds[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline void
-vn_encode_VkSparseImageOpaqueMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseImageOpaqueMemoryBindInfo *val)
-{
-    vn_encode_VkImage(enc, &val->image);
-    vn_encode_uint32_t(enc, &val->bindCount);
-    if (val->pBinds) {
-        vn_encode_array_size(enc, val->bindCount);
-        for (uint32_t i = 0; i < val->bindCount; i++)
-            vn_encode_VkSparseMemoryBind(enc, &val->pBinds[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-/* struct VkSparseImageMemoryBindInfo */
-
-static inline size_t
-vn_sizeof_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkImage(&val->image);
-    size += vn_sizeof_uint32_t(&val->bindCount);
-    if (val->pBinds) {
-        size += vn_sizeof_array_size(val->bindCount);
-        for (uint32_t i = 0; i < val->bindCount; i++)
-            size += vn_sizeof_VkSparseImageMemoryBind(&val->pBinds[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline void
-vn_encode_VkSparseImageMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseImageMemoryBindInfo *val)
-{
-    vn_encode_VkImage(enc, &val->image);
-    vn_encode_uint32_t(enc, &val->bindCount);
-    if (val->pBinds) {
-        vn_encode_array_size(enc, val->bindCount);
-        for (uint32_t i = 0; i < val->bindCount; i++)
-            vn_encode_VkSparseImageMemoryBind(enc, &val->pBinds[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-/* struct VkDeviceGroupBindSparseInfo chain */
-
-static inline size_t
-vn_sizeof_VkDeviceGroupBindSparseInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDeviceGroupBindSparseInfo_self(const VkDeviceGroupBindSparseInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->resourceDeviceIndex);
-    size += vn_sizeof_uint32_t(&val->memoryDeviceIndex);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDeviceGroupBindSparseInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDeviceGroupBindSparseInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDeviceGroupBindSparseInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDeviceGroupBindSparseInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupBindSparseInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->resourceDeviceIndex);
-    vn_encode_uint32_t(enc, &val->memoryDeviceIndex);
-}
-
-static inline void
-vn_encode_VkDeviceGroupBindSparseInfo(struct vn_cs_encoder *enc, const VkDeviceGroupBindSparseInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO });
-    vn_encode_VkDeviceGroupBindSparseInfo_pnext(enc, val->pNext);
-    vn_encode_VkDeviceGroupBindSparseInfo_self(enc, val);
-}
-
-/* struct VkTimelineSemaphoreSubmitInfo chain */
-
-static inline size_t
-vn_sizeof_VkTimelineSemaphoreSubmitInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkTimelineSemaphoreSubmitInfo_self(const VkTimelineSemaphoreSubmitInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->waitSemaphoreValueCount);
-    if (val->pWaitSemaphoreValues) {
-        size += vn_sizeof_array_size(val->waitSemaphoreValueCount);
-        size += vn_sizeof_uint64_t_array(val->pWaitSemaphoreValues, val->waitSemaphoreValueCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->signalSemaphoreValueCount);
-    if (val->pSignalSemaphoreValues) {
-        size += vn_sizeof_array_size(val->signalSemaphoreValueCount);
-        size += vn_sizeof_uint64_t_array(val->pSignalSemaphoreValues, val->signalSemaphoreValueCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_pnext(val->pNext);
-    size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkTimelineSemaphoreSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkTimelineSemaphoreSubmitInfo_self(struct vn_cs_encoder *enc, const VkTimelineSemaphoreSubmitInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->waitSemaphoreValueCount);
-    if (val->pWaitSemaphoreValues) {
-        vn_encode_array_size(enc, val->waitSemaphoreValueCount);
-        vn_encode_uint64_t_array(enc, val->pWaitSemaphoreValues, val->waitSemaphoreValueCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->signalSemaphoreValueCount);
-    if (val->pSignalSemaphoreValues) {
-        vn_encode_array_size(enc, val->signalSemaphoreValueCount);
-        vn_encode_uint64_t_array(enc, val->pSignalSemaphoreValues, val->signalSemaphoreValueCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkTimelineSemaphoreSubmitInfo(struct vn_cs_encoder *enc, const VkTimelineSemaphoreSubmitInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO });
-    vn_encode_VkTimelineSemaphoreSubmitInfo_pnext(enc, val->pNext);
-    vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, val);
-}
-
-/* struct VkBindSparseInfo chain */
-
-static inline size_t
-vn_sizeof_VkBindSparseInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkBindSparseInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkDeviceGroupBindSparseInfo_self((const VkDeviceGroupBindSparseInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkBindSparseInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self((const VkTimelineSemaphoreSubmitInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBindSparseInfo_self(const VkBindSparseInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->waitSemaphoreCount);
-    if (val->pWaitSemaphores) {
-        size += vn_sizeof_array_size(val->waitSemaphoreCount);
-        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
-            size += vn_sizeof_VkSemaphore(&val->pWaitSemaphores[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->bufferBindCount);
-    if (val->pBufferBinds) {
-        size += vn_sizeof_array_size(val->bufferBindCount);
-        for (uint32_t i = 0; i < val->bufferBindCount; i++)
-            size += vn_sizeof_VkSparseBufferMemoryBindInfo(&val->pBufferBinds[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->imageOpaqueBindCount);
-    if (val->pImageOpaqueBinds) {
-        size += vn_sizeof_array_size(val->imageOpaqueBindCount);
-        for (uint32_t i = 0; i < val->imageOpaqueBindCount; i++)
-            size += vn_sizeof_VkSparseImageOpaqueMemoryBindInfo(&val->pImageOpaqueBinds[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->imageBindCount);
-    if (val->pImageBinds) {
-        size += vn_sizeof_array_size(val->imageBindCount);
-        for (uint32_t i = 0; i < val->imageBindCount; i++)
-            size += vn_sizeof_VkSparseImageMemoryBindInfo(&val->pImageBinds[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->signalSemaphoreCount);
-    if (val->pSignalSemaphores) {
-        size += vn_sizeof_array_size(val->signalSemaphoreCount);
-        for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
-            size += vn_sizeof_VkSemaphore(&val->pSignalSemaphores[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBindSparseInfo(const VkBindSparseInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBindSparseInfo_pnext(val->pNext);
-    size += vn_sizeof_VkBindSparseInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBindSparseInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkBindSparseInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkDeviceGroupBindSparseInfo_self(enc, (const VkDeviceGroupBindSparseInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkBindSparseInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, (const VkTimelineSemaphoreSubmitInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBindSparseInfo_self(struct vn_cs_encoder *enc, const VkBindSparseInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->waitSemaphoreCount);
-    if (val->pWaitSemaphores) {
-        vn_encode_array_size(enc, val->waitSemaphoreCount);
-        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
-            vn_encode_VkSemaphore(enc, &val->pWaitSemaphores[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->bufferBindCount);
-    if (val->pBufferBinds) {
-        vn_encode_array_size(enc, val->bufferBindCount);
-        for (uint32_t i = 0; i < val->bufferBindCount; i++)
-            vn_encode_VkSparseBufferMemoryBindInfo(enc, &val->pBufferBinds[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->imageOpaqueBindCount);
-    if (val->pImageOpaqueBinds) {
-        vn_encode_array_size(enc, val->imageOpaqueBindCount);
-        for (uint32_t i = 0; i < val->imageOpaqueBindCount; i++)
-            vn_encode_VkSparseImageOpaqueMemoryBindInfo(enc, &val->pImageOpaqueBinds[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->imageBindCount);
-    if (val->pImageBinds) {
-        vn_encode_array_size(enc, val->imageBindCount);
-        for (uint32_t i = 0; i < val->imageBindCount; i++)
-            vn_encode_VkSparseImageMemoryBindInfo(enc, &val->pImageBinds[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->signalSemaphoreCount);
-    if (val->pSignalSemaphores) {
-        vn_encode_array_size(enc, val->signalSemaphoreCount);
-        for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
-            vn_encode_VkSemaphore(enc, &val->pSignalSemaphores[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkBindSparseInfo(struct vn_cs_encoder *enc, const VkBindSparseInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BIND_SPARSE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO });
-    vn_encode_VkBindSparseInfo_pnext(enc, val->pNext);
-    vn_encode_VkBindSparseInfo_self(enc, val);
-}
-
-/* struct VkImageCopy */
-
-static inline size_t
-vn_sizeof_VkImageCopy(const VkImageCopy *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource);
-    size += vn_sizeof_VkOffset3D(&val->srcOffset);
-    size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource);
-    size += vn_sizeof_VkOffset3D(&val->dstOffset);
-    size += vn_sizeof_VkExtent3D(&val->extent);
-    return size;
-}
-
-static inline void
-vn_encode_VkImageCopy(struct vn_cs_encoder *enc, const VkImageCopy *val)
-{
-    vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource);
-    vn_encode_VkOffset3D(enc, &val->srcOffset);
-    vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource);
-    vn_encode_VkOffset3D(enc, &val->dstOffset);
-    vn_encode_VkExtent3D(enc, &val->extent);
-}
-
-/* struct VkImageBlit */
-
-static inline size_t
-vn_sizeof_VkImageBlit(const VkImageBlit *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource);
-    size += vn_sizeof_array_size(2);
-    for (uint32_t i = 0; i < 2; i++)
-        size += vn_sizeof_VkOffset3D(&val->srcOffsets[i]);
-    size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource);
-    size += vn_sizeof_array_size(2);
-    for (uint32_t i = 0; i < 2; i++)
-        size += vn_sizeof_VkOffset3D(&val->dstOffsets[i]);
-    return size;
-}
-
-static inline void
-vn_encode_VkImageBlit(struct vn_cs_encoder *enc, const VkImageBlit *val)
-{
-    vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource);
-    vn_encode_array_size(enc, 2);
-    for (uint32_t i = 0; i < 2; i++)
-        vn_encode_VkOffset3D(enc, &val->srcOffsets[i]);
-    vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource);
-    vn_encode_array_size(enc, 2);
-    for (uint32_t i = 0; i < 2; i++)
-        vn_encode_VkOffset3D(enc, &val->dstOffsets[i]);
-}
-
-/* struct VkBufferImageCopy */
-
-static inline size_t
-vn_sizeof_VkBufferImageCopy(const VkBufferImageCopy *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkDeviceSize(&val->bufferOffset);
-    size += vn_sizeof_uint32_t(&val->bufferRowLength);
-    size += vn_sizeof_uint32_t(&val->bufferImageHeight);
-    size += vn_sizeof_VkImageSubresourceLayers(&val->imageSubresource);
-    size += vn_sizeof_VkOffset3D(&val->imageOffset);
-    size += vn_sizeof_VkExtent3D(&val->imageExtent);
-    return size;
-}
-
-static inline void
-vn_encode_VkBufferImageCopy(struct vn_cs_encoder *enc, const VkBufferImageCopy *val)
-{
-    vn_encode_VkDeviceSize(enc, &val->bufferOffset);
-    vn_encode_uint32_t(enc, &val->bufferRowLength);
-    vn_encode_uint32_t(enc, &val->bufferImageHeight);
-    vn_encode_VkImageSubresourceLayers(enc, &val->imageSubresource);
-    vn_encode_VkOffset3D(enc, &val->imageOffset);
-    vn_encode_VkExtent3D(enc, &val->imageExtent);
-}
-
-/* struct VkImageResolve */
-
-static inline size_t
-vn_sizeof_VkImageResolve(const VkImageResolve *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource);
-    size += vn_sizeof_VkOffset3D(&val->srcOffset);
-    size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource);
-    size += vn_sizeof_VkOffset3D(&val->dstOffset);
-    size += vn_sizeof_VkExtent3D(&val->extent);
-    return size;
-}
-
-static inline void
-vn_encode_VkImageResolve(struct vn_cs_encoder *enc, const VkImageResolve *val)
-{
-    vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource);
-    vn_encode_VkOffset3D(enc, &val->srcOffset);
-    vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource);
-    vn_encode_VkOffset3D(enc, &val->dstOffset);
-    vn_encode_VkExtent3D(enc, &val->extent);
-}
-
-/* struct VkShaderModuleCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkShaderModuleCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkShaderModuleCreateInfo_self(const VkShaderModuleCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_size_t(&val->codeSize);
-    if (val->pCode) {
-        size += vn_sizeof_array_size(val->codeSize / 4);
-        size += vn_sizeof_uint32_t_array(val->pCode, val->codeSize / 4);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkShaderModuleCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkShaderModuleCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkShaderModuleCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkShaderModuleCreateInfo_self(struct vn_cs_encoder *enc, const VkShaderModuleCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_size_t(enc, &val->codeSize);
-    if (val->pCode) {
-        vn_encode_array_size(enc, val->codeSize / 4);
-        vn_encode_uint32_t_array(enc, val->pCode, val->codeSize / 4);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkShaderModuleCreateInfo(struct vn_cs_encoder *enc, const VkShaderModuleCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO });
-    vn_encode_VkShaderModuleCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkShaderModuleCreateInfo_self(enc, val);
-}
-
-/* struct VkDescriptorSetLayoutBinding */
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->binding);
-    size += vn_sizeof_VkDescriptorType(&val->descriptorType);
-    size += vn_sizeof_uint32_t(&val->descriptorCount);
-    size += vn_sizeof_VkFlags(&val->stageFlags);
-    if (val->pImmutableSamplers) {
-        size += vn_sizeof_array_size(val->descriptorCount);
-        for (uint32_t i = 0; i < val->descriptorCount; i++)
-            size += vn_sizeof_VkSampler(&val->pImmutableSamplers[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorSetLayoutBinding(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBinding *val)
-{
-    vn_encode_uint32_t(enc, &val->binding);
-    vn_encode_VkDescriptorType(enc, &val->descriptorType);
-    vn_encode_uint32_t(enc, &val->descriptorCount);
-    vn_encode_VkFlags(enc, &val->stageFlags);
-    if (val->pImmutableSamplers) {
-        vn_encode_array_size(enc, val->descriptorCount);
-        for (uint32_t i = 0; i < val->descriptorCount; i++)
-            vn_encode_VkSampler(enc, &val->pImmutableSamplers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-/* struct VkDescriptorSetLayoutBindingFlagsCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->bindingCount);
-    if (val->pBindingFlags) {
-        size += vn_sizeof_array_size(val->bindingCount);
-        for (uint32_t i = 0; i < val->bindingCount; i++)
-            size += vn_sizeof_VkFlags(&val->pBindingFlags[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->bindingCount);
-    if (val->pBindingFlags) {
-        vn_encode_array_size(enc, val->bindingCount);
-        for (uint32_t i = 0; i < val->bindingCount; i++)
-            vn_encode_VkFlags(enc, &val->pBindingFlags[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO });
-    vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(enc, val);
-}
-
-/* struct VkDescriptorSetLayoutCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self((const VkDescriptorSetLayoutBindingFlagsCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutCreateInfo_self(const VkDescriptorSetLayoutCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->bindingCount);
-    if (val->pBindings) {
-        size += vn_sizeof_array_size(val->bindingCount);
-        for (uint32_t i = 0; i < val->bindingCount; i++)
-            size += vn_sizeof_VkDescriptorSetLayoutBinding(&val->pBindings[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(enc, (const VkDescriptorSetLayoutBindingFlagsCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDescriptorSetLayoutCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->bindingCount);
-    if (val->pBindings) {
-        vn_encode_array_size(enc, val->bindingCount);
-        for (uint32_t i = 0; i < val->bindingCount; i++)
-            vn_encode_VkDescriptorSetLayoutBinding(enc, &val->pBindings[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkDescriptorSetLayoutCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO });
-    vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkDescriptorSetLayoutCreateInfo_self(enc, val);
-}
-
-/* struct VkDescriptorPoolSize */
-
-static inline size_t
-vn_sizeof_VkDescriptorPoolSize(const VkDescriptorPoolSize *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkDescriptorType(&val->type);
-    size += vn_sizeof_uint32_t(&val->descriptorCount);
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorPoolSize(struct vn_cs_encoder *enc, const VkDescriptorPoolSize *val)
-{
-    vn_encode_VkDescriptorType(enc, &val->type);
-    vn_encode_uint32_t(enc, &val->descriptorCount);
-}
-
-/* struct VkDescriptorPoolCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkDescriptorPoolCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorPoolCreateInfo_self(const VkDescriptorPoolCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->maxSets);
-    size += vn_sizeof_uint32_t(&val->poolSizeCount);
-    if (val->pPoolSizes) {
-        size += vn_sizeof_array_size(val->poolSizeCount);
-        for (uint32_t i = 0; i < val->poolSizeCount; i++)
-            size += vn_sizeof_VkDescriptorPoolSize(&val->pPoolSizes[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDescriptorPoolCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDescriptorPoolCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDescriptorPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->maxSets);
-    vn_encode_uint32_t(enc, &val->poolSizeCount);
-    if (val->pPoolSizes) {
-        vn_encode_array_size(enc, val->poolSizeCount);
-        for (uint32_t i = 0; i < val->poolSizeCount; i++)
-            vn_encode_VkDescriptorPoolSize(enc, &val->pPoolSizes[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkDescriptorPoolCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO });
-    vn_encode_VkDescriptorPoolCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkDescriptorPoolCreateInfo_self(enc, val);
-}
-
-/* struct VkDescriptorSetVariableDescriptorCountAllocateInfo chain */
-
-static inline size_t
-vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->descriptorSetCount);
-    if (val->pDescriptorCounts) {
-        size += vn_sizeof_array_size(val->descriptorSetCount);
-        size += vn_sizeof_uint32_t_array(val->pDescriptorCounts, val->descriptorSetCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->descriptorSetCount);
-    if (val->pDescriptorCounts) {
-        vn_encode_array_size(enc, val->descriptorSetCount);
-        vn_encode_uint32_t_array(enc, val->pDescriptorCounts, val->descriptorSetCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO });
-    vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(enc, val->pNext);
-    vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(enc, val);
-}
-
-/* struct VkDescriptorSetAllocateInfo chain */
-
-static inline size_t
-vn_sizeof_VkDescriptorSetAllocateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDescriptorSetAllocateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self((const VkDescriptorSetVariableDescriptorCountAllocateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetAllocateInfo_self(const VkDescriptorSetAllocateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkDescriptorPool(&val->descriptorPool);
-    size += vn_sizeof_uint32_t(&val->descriptorSetCount);
-    if (val->pSetLayouts) {
-        size += vn_sizeof_array_size(val->descriptorSetCount);
-        for (uint32_t i = 0; i < val->descriptorSetCount; i++)
-            size += vn_sizeof_VkDescriptorSetLayout(&val->pSetLayouts[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDescriptorSetAllocateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDescriptorSetAllocateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorSetAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDescriptorSetAllocateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(enc, (const VkDescriptorSetVariableDescriptorCountAllocateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDescriptorSetAllocateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetAllocateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkDescriptorPool(enc, &val->descriptorPool);
-    vn_encode_uint32_t(enc, &val->descriptorSetCount);
-    if (val->pSetLayouts) {
-        vn_encode_array_size(enc, val->descriptorSetCount);
-        for (uint32_t i = 0; i < val->descriptorSetCount; i++)
-            vn_encode_VkDescriptorSetLayout(enc, &val->pSetLayouts[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkDescriptorSetAllocateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetAllocateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO });
-    vn_encode_VkDescriptorSetAllocateInfo_pnext(enc, val->pNext);
-    vn_encode_VkDescriptorSetAllocateInfo_self(enc, val);
-}
-
-/* struct VkSpecializationMapEntry */
-
-static inline size_t
-vn_sizeof_VkSpecializationMapEntry(const VkSpecializationMapEntry *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->constantID);
-    size += vn_sizeof_uint32_t(&val->offset);
-    size += vn_sizeof_size_t(&val->size);
-    return size;
-}
-
-static inline void
-vn_encode_VkSpecializationMapEntry(struct vn_cs_encoder *enc, const VkSpecializationMapEntry *val)
-{
-    vn_encode_uint32_t(enc, &val->constantID);
-    vn_encode_uint32_t(enc, &val->offset);
-    vn_encode_size_t(enc, &val->size);
-}
-
-/* struct VkSpecializationInfo */
-
-static inline size_t
-vn_sizeof_VkSpecializationInfo(const VkSpecializationInfo *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->mapEntryCount);
-    if (val->pMapEntries) {
-        size += vn_sizeof_array_size(val->mapEntryCount);
-        for (uint32_t i = 0; i < val->mapEntryCount; i++)
-            size += vn_sizeof_VkSpecializationMapEntry(&val->pMapEntries[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_size_t(&val->dataSize);
-    if (val->pData) {
-        size += vn_sizeof_array_size(val->dataSize);
-        size += vn_sizeof_blob_array(val->pData, val->dataSize);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline void
-vn_encode_VkSpecializationInfo(struct vn_cs_encoder *enc, const VkSpecializationInfo *val)
-{
-    vn_encode_uint32_t(enc, &val->mapEntryCount);
-    if (val->pMapEntries) {
-        vn_encode_array_size(enc, val->mapEntryCount);
-        for (uint32_t i = 0; i < val->mapEntryCount; i++)
-            vn_encode_VkSpecializationMapEntry(enc, &val->pMapEntries[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_size_t(enc, &val->dataSize);
-    if (val->pData) {
-        vn_encode_array_size(enc, val->dataSize);
-        vn_encode_blob_array(enc, val->pData, val->dataSize);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-/* struct VkPipelineShaderStageCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineShaderStageCreateInfo_self(const VkPipelineShaderStageCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkShaderStageFlagBits(&val->stage);
-    size += vn_sizeof_VkShaderModule(&val->module);
-    if (val->pName) {
-        const size_t string_size = strlen(val->pName) + 1;
-        size += vn_sizeof_array_size(string_size);
-        size += vn_sizeof_blob_array(val->pName, string_size);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_simple_pointer(val->pSpecializationInfo);
-    if (val->pSpecializationInfo)
-        size += vn_sizeof_VkSpecializationInfo(val->pSpecializationInfo);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineShaderStageCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineShaderStageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineShaderStageCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkShaderStageFlagBits(enc, &val->stage);
-    vn_encode_VkShaderModule(enc, &val->module);
-    if (val->pName) {
-        const size_t string_size = strlen(val->pName) + 1;
-        vn_encode_array_size(enc, string_size);
-        vn_encode_blob_array(enc, val->pName, string_size);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (vn_encode_simple_pointer(enc, val->pSpecializationInfo))
-        vn_encode_VkSpecializationInfo(enc, val->pSpecializationInfo);
-}
-
-static inline void
-vn_encode_VkPipelineShaderStageCreateInfo(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO });
-    vn_encode_VkPipelineShaderStageCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineShaderStageCreateInfo_self(enc, val);
-}
-
-/* struct VkComputePipelineCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkComputePipelineCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkComputePipelineCreateInfo_self(const VkComputePipelineCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkPipelineShaderStageCreateInfo(&val->stage);
-    size += vn_sizeof_VkPipelineLayout(&val->layout);
-    size += vn_sizeof_VkPipeline(&val->basePipelineHandle);
-    size += vn_sizeof_int32_t(&val->basePipelineIndex);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkComputePipelineCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkComputePipelineCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkComputePipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkComputePipelineCreateInfo_self(struct vn_cs_encoder *enc, const VkComputePipelineCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkPipelineShaderStageCreateInfo(enc, &val->stage);
-    vn_encode_VkPipelineLayout(enc, &val->layout);
-    vn_encode_VkPipeline(enc, &val->basePipelineHandle);
-    vn_encode_int32_t(enc, &val->basePipelineIndex);
-}
-
-static inline void
-vn_encode_VkComputePipelineCreateInfo(struct vn_cs_encoder *enc, const VkComputePipelineCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO });
-    vn_encode_VkComputePipelineCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkComputePipelineCreateInfo_self(enc, val);
-}
-
-/* struct VkVertexInputBindingDescription */
-
-static inline size_t
-vn_sizeof_VkVertexInputBindingDescription(const VkVertexInputBindingDescription *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->binding);
-    size += vn_sizeof_uint32_t(&val->stride);
-    size += vn_sizeof_VkVertexInputRate(&val->inputRate);
-    return size;
-}
-
-static inline void
-vn_encode_VkVertexInputBindingDescription(struct vn_cs_encoder *enc, const VkVertexInputBindingDescription *val)
-{
-    vn_encode_uint32_t(enc, &val->binding);
-    vn_encode_uint32_t(enc, &val->stride);
-    vn_encode_VkVertexInputRate(enc, &val->inputRate);
-}
-
-/* struct VkVertexInputAttributeDescription */
-
-static inline size_t
-vn_sizeof_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->location);
-    size += vn_sizeof_uint32_t(&val->binding);
-    size += vn_sizeof_VkFormat(&val->format);
-    size += vn_sizeof_uint32_t(&val->offset);
-    return size;
-}
-
-static inline void
-vn_encode_VkVertexInputAttributeDescription(struct vn_cs_encoder *enc, const VkVertexInputAttributeDescription *val)
-{
-    vn_encode_uint32_t(enc, &val->location);
-    vn_encode_uint32_t(enc, &val->binding);
-    vn_encode_VkFormat(enc, &val->format);
-    vn_encode_uint32_t(enc, &val->offset);
-}
-
-/* struct VkPipelineVertexInputStateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(const VkPipelineVertexInputStateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->vertexBindingDescriptionCount);
-    if (val->pVertexBindingDescriptions) {
-        size += vn_sizeof_array_size(val->vertexBindingDescriptionCount);
-        for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++)
-            size += vn_sizeof_VkVertexInputBindingDescription(&val->pVertexBindingDescriptions[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->vertexAttributeDescriptionCount);
-    if (val->pVertexAttributeDescriptions) {
-        size += vn_sizeof_array_size(val->vertexAttributeDescriptionCount);
-        for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++)
-            size += vn_sizeof_VkVertexInputAttributeDescription(&val->pVertexAttributeDescriptions[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineVertexInputStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineVertexInputStateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->vertexBindingDescriptionCount);
-    if (val->pVertexBindingDescriptions) {
-        vn_encode_array_size(enc, val->vertexBindingDescriptionCount);
-        for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++)
-            vn_encode_VkVertexInputBindingDescription(enc, &val->pVertexBindingDescriptions[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->vertexAttributeDescriptionCount);
-    if (val->pVertexAttributeDescriptions) {
-        vn_encode_array_size(enc, val->vertexAttributeDescriptionCount);
-        for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++)
-            vn_encode_VkVertexInputAttributeDescription(enc, &val->pVertexAttributeDescriptions[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkPipelineVertexInputStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineVertexInputStateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO });
-    vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineVertexInputStateCreateInfo_self(enc, val);
-}
-
-/* struct VkPipelineInputAssemblyStateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(const VkPipelineInputAssemblyStateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkPrimitiveTopology(&val->topology);
-    size += vn_sizeof_VkBool32(&val->primitiveRestartEnable);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineInputAssemblyStateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkPrimitiveTopology(enc, &val->topology);
-    vn_encode_VkBool32(enc, &val->primitiveRestartEnable);
-}
-
-static inline void
-vn_encode_VkPipelineInputAssemblyStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineInputAssemblyStateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO });
-    vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(enc, val);
-}
-
-/* struct VkPipelineTessellationDomainOriginStateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(const VkPipelineTessellationDomainOriginStateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkTessellationDomainOrigin(&val->domainOrigin);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineTessellationDomainOriginStateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkTessellationDomainOrigin(enc, &val->domainOrigin);
-}
-
-static inline void
-vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineTessellationDomainOriginStateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO });
-    vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(enc, val);
-}
-
-/* struct VkPipelineTessellationStateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self((const VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineTessellationStateCreateInfo_self(const VkPipelineTessellationStateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->patchControlPoints);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineTessellationStateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineTessellationStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPipelineTessellationStateCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(enc, (const VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineTessellationStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineTessellationStateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->patchControlPoints);
-}
-
-static inline void
-vn_encode_VkPipelineTessellationStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineTessellationStateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO });
-    vn_encode_VkPipelineTessellationStateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineTessellationStateCreateInfo_self(enc, val);
-}
-
-/* struct VkPipelineViewportStateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineViewportStateCreateInfo_self(const VkPipelineViewportStateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->viewportCount);
-    if (val->pViewports) {
-        size += vn_sizeof_array_size(val->viewportCount);
-        for (uint32_t i = 0; i < val->viewportCount; i++)
-            size += vn_sizeof_VkViewport(&val->pViewports[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->scissorCount);
-    if (val->pScissors) {
-        size += vn_sizeof_array_size(val->scissorCount);
-        for (uint32_t i = 0; i < val->scissorCount; i++)
-            size += vn_sizeof_VkRect2D(&val->pScissors[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineViewportStateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineViewportStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineViewportStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineViewportStateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->viewportCount);
-    if (val->pViewports) {
-        vn_encode_array_size(enc, val->viewportCount);
-        for (uint32_t i = 0; i < val->viewportCount; i++)
-            vn_encode_VkViewport(enc, &val->pViewports[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->scissorCount);
-    if (val->pScissors) {
-        vn_encode_array_size(enc, val->scissorCount);
-        for (uint32_t i = 0; i < val->scissorCount; i++)
-            vn_encode_VkRect2D(enc, &val->pScissors[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkPipelineViewportStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineViewportStateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO });
-    vn_encode_VkPipelineViewportStateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineViewportStateCreateInfo_self(enc, val);
-}
-
-/* struct VkPipelineRasterizationStateStreamCreateInfoEXT chain */
-
-static inline size_t
-vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->rasterizationStream);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->rasterizationStream);
-}
-
-static inline void
-vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT });
-    vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(enc, val->pNext);
-    vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(enc, val);
-}
-
-/* struct VkPipelineRasterizationStateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self((const VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(const VkPipelineRasterizationStateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkBool32(&val->depthClampEnable);
-    size += vn_sizeof_VkBool32(&val->rasterizerDiscardEnable);
-    size += vn_sizeof_VkPolygonMode(&val->polygonMode);
-    size += vn_sizeof_VkFlags(&val->cullMode);
-    size += vn_sizeof_VkFrontFace(&val->frontFace);
-    size += vn_sizeof_VkBool32(&val->depthBiasEnable);
-    size += vn_sizeof_float(&val->depthBiasConstantFactor);
-    size += vn_sizeof_float(&val->depthBiasClamp);
-    size += vn_sizeof_float(&val->depthBiasSlopeFactor);
-    size += vn_sizeof_float(&val->lineWidth);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(enc, (const VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineRasterizationStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkBool32(enc, &val->depthClampEnable);
-    vn_encode_VkBool32(enc, &val->rasterizerDiscardEnable);
-    vn_encode_VkPolygonMode(enc, &val->polygonMode);
-    vn_encode_VkFlags(enc, &val->cullMode);
-    vn_encode_VkFrontFace(enc, &val->frontFace);
-    vn_encode_VkBool32(enc, &val->depthBiasEnable);
-    vn_encode_float(enc, &val->depthBiasConstantFactor);
-    vn_encode_float(enc, &val->depthBiasClamp);
-    vn_encode_float(enc, &val->depthBiasSlopeFactor);
-    vn_encode_float(enc, &val->lineWidth);
-}
-
-static inline void
-vn_encode_VkPipelineRasterizationStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO });
-    vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineRasterizationStateCreateInfo_self(enc, val);
-}
-
-/* struct VkPipelineMultisampleStateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(const VkPipelineMultisampleStateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkSampleCountFlagBits(&val->rasterizationSamples);
-    size += vn_sizeof_VkBool32(&val->sampleShadingEnable);
-    size += vn_sizeof_float(&val->minSampleShading);
-    if (val->pSampleMask) {
-        size += vn_sizeof_array_size((val->rasterizationSamples + 31) / 32);
-        size += vn_sizeof_VkSampleMask_array(val->pSampleMask, (val->rasterizationSamples + 31) / 32);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_VkBool32(&val->alphaToCoverageEnable);
-    size += vn_sizeof_VkBool32(&val->alphaToOneEnable);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineMultisampleStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineMultisampleStateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkSampleCountFlagBits(enc, &val->rasterizationSamples);
-    vn_encode_VkBool32(enc, &val->sampleShadingEnable);
-    vn_encode_float(enc, &val->minSampleShading);
-    if (val->pSampleMask) {
-        vn_encode_array_size(enc, (val->rasterizationSamples + 31) / 32);
-        vn_encode_VkSampleMask_array(enc, val->pSampleMask, (val->rasterizationSamples + 31) / 32);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_VkBool32(enc, &val->alphaToCoverageEnable);
-    vn_encode_VkBool32(enc, &val->alphaToOneEnable);
-}
-
-static inline void
-vn_encode_VkPipelineMultisampleStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineMultisampleStateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO });
-    vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineMultisampleStateCreateInfo_self(enc, val);
-}
-
-/* struct VkPipelineColorBlendAttachmentState */
-
-static inline size_t
-vn_sizeof_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkBool32(&val->blendEnable);
-    size += vn_sizeof_VkBlendFactor(&val->srcColorBlendFactor);
-    size += vn_sizeof_VkBlendFactor(&val->dstColorBlendFactor);
-    size += vn_sizeof_VkBlendOp(&val->colorBlendOp);
-    size += vn_sizeof_VkBlendFactor(&val->srcAlphaBlendFactor);
-    size += vn_sizeof_VkBlendFactor(&val->dstAlphaBlendFactor);
-    size += vn_sizeof_VkBlendOp(&val->alphaBlendOp);
-    size += vn_sizeof_VkFlags(&val->colorWriteMask);
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineColorBlendAttachmentState(struct vn_cs_encoder *enc, const VkPipelineColorBlendAttachmentState *val)
-{
-    vn_encode_VkBool32(enc, &val->blendEnable);
-    vn_encode_VkBlendFactor(enc, &val->srcColorBlendFactor);
-    vn_encode_VkBlendFactor(enc, &val->dstColorBlendFactor);
-    vn_encode_VkBlendOp(enc, &val->colorBlendOp);
-    vn_encode_VkBlendFactor(enc, &val->srcAlphaBlendFactor);
-    vn_encode_VkBlendFactor(enc, &val->dstAlphaBlendFactor);
-    vn_encode_VkBlendOp(enc, &val->alphaBlendOp);
-    vn_encode_VkFlags(enc, &val->colorWriteMask);
-}
-
-/* struct VkPipelineColorBlendStateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(const VkPipelineColorBlendStateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkBool32(&val->logicOpEnable);
-    size += vn_sizeof_VkLogicOp(&val->logicOp);
-    size += vn_sizeof_uint32_t(&val->attachmentCount);
-    if (val->pAttachments) {
-        size += vn_sizeof_array_size(val->attachmentCount);
-        for (uint32_t i = 0; i < val->attachmentCount; i++)
-            size += vn_sizeof_VkPipelineColorBlendAttachmentState(&val->pAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_array_size(4);
-    size += vn_sizeof_float_array(val->blendConstants, 4);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineColorBlendStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkBool32(enc, &val->logicOpEnable);
-    vn_encode_VkLogicOp(enc, &val->logicOp);
-    vn_encode_uint32_t(enc, &val->attachmentCount);
-    if (val->pAttachments) {
-        vn_encode_array_size(enc, val->attachmentCount);
-        for (uint32_t i = 0; i < val->attachmentCount; i++)
-            vn_encode_VkPipelineColorBlendAttachmentState(enc, &val->pAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_array_size(enc, 4);
-    vn_encode_float_array(enc, val->blendConstants, 4);
-}
-
-static inline void
-vn_encode_VkPipelineColorBlendStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO });
-    vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineColorBlendStateCreateInfo_self(enc, val);
-}
-
-/* struct VkPipelineDynamicStateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineDynamicStateCreateInfo_self(const VkPipelineDynamicStateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->dynamicStateCount);
-    if (val->pDynamicStates) {
-        size += vn_sizeof_array_size(val->dynamicStateCount);
-        size += vn_sizeof_VkDynamicState_array(val->pDynamicStates, val->dynamicStateCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineDynamicStateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineDynamicStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineDynamicStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineDynamicStateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->dynamicStateCount);
-    if (val->pDynamicStates) {
-        vn_encode_array_size(enc, val->dynamicStateCount);
-        vn_encode_VkDynamicState_array(enc, val->pDynamicStates, val->dynamicStateCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkPipelineDynamicStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineDynamicStateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO });
-    vn_encode_VkPipelineDynamicStateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineDynamicStateCreateInfo_self(enc, val);
-}
-
-/* struct VkStencilOpState */
-
-static inline size_t
-vn_sizeof_VkStencilOpState(const VkStencilOpState *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkStencilOp(&val->failOp);
-    size += vn_sizeof_VkStencilOp(&val->passOp);
-    size += vn_sizeof_VkStencilOp(&val->depthFailOp);
-    size += vn_sizeof_VkCompareOp(&val->compareOp);
-    size += vn_sizeof_uint32_t(&val->compareMask);
-    size += vn_sizeof_uint32_t(&val->writeMask);
-    size += vn_sizeof_uint32_t(&val->reference);
-    return size;
-}
-
-static inline void
-vn_encode_VkStencilOpState(struct vn_cs_encoder *enc, const VkStencilOpState *val)
-{
-    vn_encode_VkStencilOp(enc, &val->failOp);
-    vn_encode_VkStencilOp(enc, &val->passOp);
-    vn_encode_VkStencilOp(enc, &val->depthFailOp);
-    vn_encode_VkCompareOp(enc, &val->compareOp);
-    vn_encode_uint32_t(enc, &val->compareMask);
-    vn_encode_uint32_t(enc, &val->writeMask);
-    vn_encode_uint32_t(enc, &val->reference);
-}
-
-/* struct VkPipelineDepthStencilStateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(const VkPipelineDepthStencilStateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkBool32(&val->depthTestEnable);
-    size += vn_sizeof_VkBool32(&val->depthWriteEnable);
-    size += vn_sizeof_VkCompareOp(&val->depthCompareOp);
-    size += vn_sizeof_VkBool32(&val->depthBoundsTestEnable);
-    size += vn_sizeof_VkBool32(&val->stencilTestEnable);
-    size += vn_sizeof_VkStencilOpState(&val->front);
-    size += vn_sizeof_VkStencilOpState(&val->back);
-    size += vn_sizeof_float(&val->minDepthBounds);
-    size += vn_sizeof_float(&val->maxDepthBounds);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineDepthStencilStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkBool32(enc, &val->depthTestEnable);
-    vn_encode_VkBool32(enc, &val->depthWriteEnable);
-    vn_encode_VkCompareOp(enc, &val->depthCompareOp);
-    vn_encode_VkBool32(enc, &val->depthBoundsTestEnable);
-    vn_encode_VkBool32(enc, &val->stencilTestEnable);
-    vn_encode_VkStencilOpState(enc, &val->front);
-    vn_encode_VkStencilOpState(enc, &val->back);
-    vn_encode_float(enc, &val->minDepthBounds);
-    vn_encode_float(enc, &val->maxDepthBounds);
-}
-
-static inline void
-vn_encode_VkPipelineDepthStencilStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO });
-    vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineDepthStencilStateCreateInfo_self(enc, val);
-}
-
-/* struct VkGraphicsPipelineCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkGraphicsPipelineCreateInfo_self(const VkGraphicsPipelineCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->stageCount);
-    if (val->pStages) {
-        size += vn_sizeof_array_size(val->stageCount);
-        for (uint32_t i = 0; i < val->stageCount; i++)
-            size += vn_sizeof_VkPipelineShaderStageCreateInfo(&val->pStages[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_simple_pointer(val->pVertexInputState);
-    if (val->pVertexInputState)
-        size += vn_sizeof_VkPipelineVertexInputStateCreateInfo(val->pVertexInputState);
-    size += vn_sizeof_simple_pointer(val->pInputAssemblyState);
-    if (val->pInputAssemblyState)
-        size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(val->pInputAssemblyState);
-    size += vn_sizeof_simple_pointer(val->pTessellationState);
-    if (val->pTessellationState)
-        size += vn_sizeof_VkPipelineTessellationStateCreateInfo(val->pTessellationState);
-    size += vn_sizeof_simple_pointer(val->pViewportState);
-    if (val->pViewportState)
-        size += vn_sizeof_VkPipelineViewportStateCreateInfo(val->pViewportState);
-    size += vn_sizeof_simple_pointer(val->pRasterizationState);
-    if (val->pRasterizationState)
-        size += vn_sizeof_VkPipelineRasterizationStateCreateInfo(val->pRasterizationState);
-    size += vn_sizeof_simple_pointer(val->pMultisampleState);
-    if (val->pMultisampleState)
-        size += vn_sizeof_VkPipelineMultisampleStateCreateInfo(val->pMultisampleState);
-    size += vn_sizeof_simple_pointer(val->pDepthStencilState);
-    if (val->pDepthStencilState)
-        size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo(val->pDepthStencilState);
-    size += vn_sizeof_simple_pointer(val->pColorBlendState);
-    if (val->pColorBlendState)
-        size += vn_sizeof_VkPipelineColorBlendStateCreateInfo(val->pColorBlendState);
-    size += vn_sizeof_simple_pointer(val->pDynamicState);
-    if (val->pDynamicState)
-        size += vn_sizeof_VkPipelineDynamicStateCreateInfo(val->pDynamicState);
-    size += vn_sizeof_VkPipelineLayout(&val->layout);
-    size += vn_sizeof_VkRenderPass(&val->renderPass);
-    size += vn_sizeof_uint32_t(&val->subpass);
-    size += vn_sizeof_VkPipeline(&val->basePipelineHandle);
-    size += vn_sizeof_int32_t(&val->basePipelineIndex);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkGraphicsPipelineCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkGraphicsPipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkGraphicsPipelineCreateInfo_self(struct vn_cs_encoder *enc, const VkGraphicsPipelineCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->stageCount);
-    if (val->pStages) {
-        vn_encode_array_size(enc, val->stageCount);
-        for (uint32_t i = 0; i < val->stageCount; i++)
-            vn_encode_VkPipelineShaderStageCreateInfo(enc, &val->pStages[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (vn_encode_simple_pointer(enc, val->pVertexInputState))
-        vn_encode_VkPipelineVertexInputStateCreateInfo(enc, val->pVertexInputState);
-    if (vn_encode_simple_pointer(enc, val->pInputAssemblyState))
-        vn_encode_VkPipelineInputAssemblyStateCreateInfo(enc, val->pInputAssemblyState);
-    if (vn_encode_simple_pointer(enc, val->pTessellationState))
-        vn_encode_VkPipelineTessellationStateCreateInfo(enc, val->pTessellationState);
-    if (vn_encode_simple_pointer(enc, val->pViewportState))
-        vn_encode_VkPipelineViewportStateCreateInfo(enc, val->pViewportState);
-    if (vn_encode_simple_pointer(enc, val->pRasterizationState))
-        vn_encode_VkPipelineRasterizationStateCreateInfo(enc, val->pRasterizationState);
-    if (vn_encode_simple_pointer(enc, val->pMultisampleState))
-        vn_encode_VkPipelineMultisampleStateCreateInfo(enc, val->pMultisampleState);
-    if (vn_encode_simple_pointer(enc, val->pDepthStencilState))
-        vn_encode_VkPipelineDepthStencilStateCreateInfo(enc, val->pDepthStencilState);
-    if (vn_encode_simple_pointer(enc, val->pColorBlendState))
-        vn_encode_VkPipelineColorBlendStateCreateInfo(enc, val->pColorBlendState);
-    if (vn_encode_simple_pointer(enc, val->pDynamicState))
-        vn_encode_VkPipelineDynamicStateCreateInfo(enc, val->pDynamicState);
-    vn_encode_VkPipelineLayout(enc, &val->layout);
-    vn_encode_VkRenderPass(enc, &val->renderPass);
-    vn_encode_uint32_t(enc, &val->subpass);
-    vn_encode_VkPipeline(enc, &val->basePipelineHandle);
-    vn_encode_int32_t(enc, &val->basePipelineIndex);
-}
-
-static inline void
-vn_encode_VkGraphicsPipelineCreateInfo(struct vn_cs_encoder *enc, const VkGraphicsPipelineCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO });
-    vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkGraphicsPipelineCreateInfo_self(enc, val);
-}
-
-/* struct VkPipelineCacheCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineCacheCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineCacheCreateInfo_self(const VkPipelineCacheCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_size_t(&val->initialDataSize);
-    if (val->pInitialData) {
-        size += vn_sizeof_array_size(val->initialDataSize);
-        size += vn_sizeof_blob_array(val->pInitialData, val->initialDataSize);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineCacheCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineCacheCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineCacheCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineCacheCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineCacheCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_size_t(enc, &val->initialDataSize);
-    if (val->pInitialData) {
-        vn_encode_array_size(enc, val->initialDataSize);
-        vn_encode_blob_array(enc, val->pInitialData, val->initialDataSize);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkPipelineCacheCreateInfo(struct vn_cs_encoder *enc, const VkPipelineCacheCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO });
-    vn_encode_VkPipelineCacheCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineCacheCreateInfo_self(enc, val);
-}
-
-/* struct VkPushConstantRange */
-
-static inline size_t
-vn_sizeof_VkPushConstantRange(const VkPushConstantRange *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->stageFlags);
-    size += vn_sizeof_uint32_t(&val->offset);
-    size += vn_sizeof_uint32_t(&val->size);
-    return size;
-}
-
-static inline void
-vn_encode_VkPushConstantRange(struct vn_cs_encoder *enc, const VkPushConstantRange *val)
-{
-    vn_encode_VkFlags(enc, &val->stageFlags);
-    vn_encode_uint32_t(enc, &val->offset);
-    vn_encode_uint32_t(enc, &val->size);
-}
-
-/* struct VkPipelineLayoutCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkPipelineLayoutCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPipelineLayoutCreateInfo_self(const VkPipelineLayoutCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->setLayoutCount);
-    if (val->pSetLayouts) {
-        size += vn_sizeof_array_size(val->setLayoutCount);
-        for (uint32_t i = 0; i < val->setLayoutCount; i++)
-            size += vn_sizeof_VkDescriptorSetLayout(&val->pSetLayouts[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->pushConstantRangeCount);
-    if (val->pPushConstantRanges) {
-        size += vn_sizeof_array_size(val->pushConstantRangeCount);
-        for (uint32_t i = 0; i < val->pushConstantRangeCount; i++)
-            size += vn_sizeof_VkPushConstantRange(&val->pPushConstantRanges[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPipelineLayoutCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPipelineLayoutCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPipelineLayoutCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPipelineLayoutCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineLayoutCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->setLayoutCount);
-    if (val->pSetLayouts) {
-        vn_encode_array_size(enc, val->setLayoutCount);
-        for (uint32_t i = 0; i < val->setLayoutCount; i++)
-            vn_encode_VkDescriptorSetLayout(enc, &val->pSetLayouts[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->pushConstantRangeCount);
-    if (val->pPushConstantRanges) {
-        vn_encode_array_size(enc, val->pushConstantRangeCount);
-        for (uint32_t i = 0; i < val->pushConstantRangeCount; i++)
-            vn_encode_VkPushConstantRange(enc, &val->pPushConstantRanges[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkPipelineLayoutCreateInfo(struct vn_cs_encoder *enc, const VkPipelineLayoutCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO });
-    vn_encode_VkPipelineLayoutCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkPipelineLayoutCreateInfo_self(enc, val);
-}
-
-/* struct VkSamplerReductionModeCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSamplerReductionModeCreateInfo_self(const VkSamplerReductionModeCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkSamplerReductionMode(&val->reductionMode);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSamplerReductionModeCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSamplerReductionModeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSamplerReductionModeCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkSamplerReductionMode(enc, &val->reductionMode);
-}
-
-static inline void
-vn_encode_VkSamplerReductionModeCreateInfo(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO });
-    vn_encode_VkSamplerReductionModeCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkSamplerReductionModeCreateInfo_self(enc, val);
-}
-
-/* struct VkSamplerCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkSamplerCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkSamplerYcbcrConversionInfo_self((const VkSamplerYcbcrConversionInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkSamplerReductionModeCreateInfo_self((const VkSamplerReductionModeCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSamplerCreateInfo_self(const VkSamplerCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkFilter(&val->magFilter);
-    size += vn_sizeof_VkFilter(&val->minFilter);
-    size += vn_sizeof_VkSamplerMipmapMode(&val->mipmapMode);
-    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeU);
-    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeV);
-    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeW);
-    size += vn_sizeof_float(&val->mipLodBias);
-    size += vn_sizeof_VkBool32(&val->anisotropyEnable);
-    size += vn_sizeof_float(&val->maxAnisotropy);
-    size += vn_sizeof_VkBool32(&val->compareEnable);
-    size += vn_sizeof_VkCompareOp(&val->compareOp);
-    size += vn_sizeof_float(&val->minLod);
-    size += vn_sizeof_float(&val->maxLod);
-    size += vn_sizeof_VkBorderColor(&val->borderColor);
-    size += vn_sizeof_VkBool32(&val->unnormalizedCoordinates);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSamplerCreateInfo(const VkSamplerCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSamplerCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSamplerCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSamplerCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkSamplerYcbcrConversionInfo_self(enc, (const VkSamplerYcbcrConversionInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkSamplerReductionModeCreateInfo_self(enc, (const VkSamplerReductionModeCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSamplerCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkFilter(enc, &val->magFilter);
-    vn_encode_VkFilter(enc, &val->minFilter);
-    vn_encode_VkSamplerMipmapMode(enc, &val->mipmapMode);
-    vn_encode_VkSamplerAddressMode(enc, &val->addressModeU);
-    vn_encode_VkSamplerAddressMode(enc, &val->addressModeV);
-    vn_encode_VkSamplerAddressMode(enc, &val->addressModeW);
-    vn_encode_float(enc, &val->mipLodBias);
-    vn_encode_VkBool32(enc, &val->anisotropyEnable);
-    vn_encode_float(enc, &val->maxAnisotropy);
-    vn_encode_VkBool32(enc, &val->compareEnable);
-    vn_encode_VkCompareOp(enc, &val->compareOp);
-    vn_encode_float(enc, &val->minLod);
-    vn_encode_float(enc, &val->maxLod);
-    vn_encode_VkBorderColor(enc, &val->borderColor);
-    vn_encode_VkBool32(enc, &val->unnormalizedCoordinates);
-}
-
-static inline void
-vn_encode_VkSamplerCreateInfo(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO });
-    vn_encode_VkSamplerCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkSamplerCreateInfo_self(enc, val);
-}
-
-/* struct VkCommandPoolCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkCommandPoolCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkCommandPoolCreateInfo_self(const VkCommandPoolCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkCommandPoolCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkCommandPoolCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkCommandPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkCommandPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkCommandPoolCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->queueFamilyIndex);
-}
-
-static inline void
-vn_encode_VkCommandPoolCreateInfo(struct vn_cs_encoder *enc, const VkCommandPoolCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO });
-    vn_encode_VkCommandPoolCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkCommandPoolCreateInfo_self(enc, val);
-}
-
-/* struct VkCommandBufferAllocateInfo chain */
-
-static inline size_t
-vn_sizeof_VkCommandBufferAllocateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkCommandBufferAllocateInfo_self(const VkCommandBufferAllocateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkCommandPool(&val->commandPool);
-    size += vn_sizeof_VkCommandBufferLevel(&val->level);
-    size += vn_sizeof_uint32_t(&val->commandBufferCount);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkCommandBufferAllocateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkCommandBufferAllocateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkCommandBufferAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkCommandBufferAllocateInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferAllocateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkCommandPool(enc, &val->commandPool);
-    vn_encode_VkCommandBufferLevel(enc, &val->level);
-    vn_encode_uint32_t(enc, &val->commandBufferCount);
-}
-
-static inline void
-vn_encode_VkCommandBufferAllocateInfo(struct vn_cs_encoder *enc, const VkCommandBufferAllocateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO });
-    vn_encode_VkCommandBufferAllocateInfo_pnext(enc, val->pNext);
-    vn_encode_VkCommandBufferAllocateInfo_self(enc, val);
-}
-
-/* struct VkCommandBufferInheritanceInfo chain */
-
-static inline size_t
-vn_sizeof_VkCommandBufferInheritanceInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkCommandBufferInheritanceInfo_self(const VkCommandBufferInheritanceInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkRenderPass(&val->renderPass);
-    size += vn_sizeof_uint32_t(&val->subpass);
-    size += vn_sizeof_VkFramebuffer(&val->framebuffer);
-    size += vn_sizeof_VkBool32(&val->occlusionQueryEnable);
-    size += vn_sizeof_VkFlags(&val->queryFlags);
-    size += vn_sizeof_VkFlags(&val->pipelineStatistics);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkCommandBufferInheritanceInfo_pnext(val->pNext);
-    size += vn_sizeof_VkCommandBufferInheritanceInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkCommandBufferInheritanceInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkCommandBufferInheritanceInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferInheritanceInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkRenderPass(enc, &val->renderPass);
-    vn_encode_uint32_t(enc, &val->subpass);
-    vn_encode_VkFramebuffer(enc, &val->framebuffer);
-    vn_encode_VkBool32(enc, &val->occlusionQueryEnable);
-    vn_encode_VkFlags(enc, &val->queryFlags);
-    vn_encode_VkFlags(enc, &val->pipelineStatistics);
-}
-
-static inline void
-vn_encode_VkCommandBufferInheritanceInfo(struct vn_cs_encoder *enc, const VkCommandBufferInheritanceInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO });
-    vn_encode_VkCommandBufferInheritanceInfo_pnext(enc, val->pNext);
-    vn_encode_VkCommandBufferInheritanceInfo_self(enc, val);
-}
-
-static inline void
-vn_decode_VkCommandBufferInheritanceInfo_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkCommandBufferInheritanceInfo_self(struct vn_cs_decoder *dec, VkCommandBufferInheritanceInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkRenderPass(dec, &val->renderPass);
-    vn_decode_uint32_t(dec, &val->subpass);
-    vn_decode_VkFramebuffer(dec, &val->framebuffer);
-    vn_decode_VkBool32(dec, &val->occlusionQueryEnable);
-    vn_decode_VkFlags(dec, &val->queryFlags);
-    vn_decode_VkFlags(dec, &val->pipelineStatistics);
-}
-
-static inline void
-vn_decode_VkCommandBufferInheritanceInfo(struct vn_cs_decoder *dec, VkCommandBufferInheritanceInfo *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO);
-
-    assert(val->sType == stype);
-    vn_decode_VkCommandBufferInheritanceInfo_pnext(dec, val->pNext);
-    vn_decode_VkCommandBufferInheritanceInfo_self(dec, val);
-}
-
-/* struct VkDeviceGroupCommandBufferBeginInfo chain */
-
-static inline size_t
-vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_self(const VkDeviceGroupCommandBufferBeginInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->deviceMask);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDeviceGroupCommandBufferBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDeviceGroupCommandBufferBeginInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupCommandBufferBeginInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->deviceMask);
-}
-
-static inline void
-vn_encode_VkDeviceGroupCommandBufferBeginInfo(struct vn_cs_encoder *enc, const VkDeviceGroupCommandBufferBeginInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO });
-    vn_encode_VkDeviceGroupCommandBufferBeginInfo_pnext(enc, val->pNext);
-    vn_encode_VkDeviceGroupCommandBufferBeginInfo_self(enc, val);
-}
-
-static inline void
-vn_decode_VkDeviceGroupCommandBufferBeginInfo_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkDeviceGroupCommandBufferBeginInfo_self(struct vn_cs_decoder *dec, VkDeviceGroupCommandBufferBeginInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->deviceMask);
-}
-
-static inline void
-vn_decode_VkDeviceGroupCommandBufferBeginInfo(struct vn_cs_decoder *dec, VkDeviceGroupCommandBufferBeginInfo *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO);
-
-    assert(val->sType == stype);
-    vn_decode_VkDeviceGroupCommandBufferBeginInfo_pnext(dec, val->pNext);
-    vn_decode_VkDeviceGroupCommandBufferBeginInfo_self(dec, val);
-}
-
-/* struct VkCommandBufferBeginInfo chain */
-
-static inline size_t
-vn_sizeof_VkCommandBufferBeginInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkCommandBufferBeginInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_self((const VkDeviceGroupCommandBufferBeginInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkCommandBufferBeginInfo_self(const VkCommandBufferBeginInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_simple_pointer(val->pInheritanceInfo);
-    if (val->pInheritanceInfo)
-        size += vn_sizeof_VkCommandBufferInheritanceInfo(val->pInheritanceInfo);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkCommandBufferBeginInfo_pnext(val->pNext);
-    size += vn_sizeof_VkCommandBufferBeginInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkCommandBufferBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkCommandBufferBeginInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkDeviceGroupCommandBufferBeginInfo_self(enc, (const VkDeviceGroupCommandBufferBeginInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkCommandBufferBeginInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferBeginInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    if (vn_encode_simple_pointer(enc, val->pInheritanceInfo))
-        vn_encode_VkCommandBufferInheritanceInfo(enc, val->pInheritanceInfo);
-}
-
-static inline void
-vn_encode_VkCommandBufferBeginInfo(struct vn_cs_encoder *enc, const VkCommandBufferBeginInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO });
-    vn_encode_VkCommandBufferBeginInfo_pnext(enc, val->pNext);
-    vn_encode_VkCommandBufferBeginInfo_self(enc, val);
-}
-
-static inline void
-vn_decode_VkCommandBufferBeginInfo_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
-    VkStructureType stype;
-
-    if (!vn_decode_simple_pointer(dec))
-        return;
-
-    vn_decode_VkStructureType(dec, &stype);
-    while (true) {
-        assert(pnext);
-        if (pnext->sType == stype)
-            break;
-    }
-
-    switch ((int32_t)pnext->sType) {
-    case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
-        vn_decode_VkCommandBufferBeginInfo_pnext(dec, pnext->pNext);
-        vn_decode_VkDeviceGroupCommandBufferBeginInfo_self(dec, (VkDeviceGroupCommandBufferBeginInfo *)pnext);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_decode_VkCommandBufferBeginInfo_self(struct vn_cs_decoder *dec, VkCommandBufferBeginInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkFlags(dec, &val->flags);
-    if (vn_decode_simple_pointer(dec)) {
-        vn_decode_VkCommandBufferInheritanceInfo(dec, (VkCommandBufferInheritanceInfo *)val->pInheritanceInfo);
-    } else {
-        val->pInheritanceInfo = NULL;
-    }
-}
-
-static inline void
-vn_decode_VkCommandBufferBeginInfo(struct vn_cs_decoder *dec, VkCommandBufferBeginInfo *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO);
-
-    assert(val->sType == stype);
-    vn_decode_VkCommandBufferBeginInfo_pnext(dec, val->pNext);
-    vn_decode_VkCommandBufferBeginInfo_self(dec, val);
-}
-
-/* union VkClearColorValue */
-
-static inline size_t
-vn_sizeof_VkClearColorValue_tag(const VkClearColorValue *val, uint32_t tag)
-{
-    size_t size = vn_sizeof_uint32_t(&tag);
-    switch (tag) {
-    case 0:
-        size += vn_sizeof_array_size(4);
-    size += vn_sizeof_float_array(val->float32, 4);
-        break;
-    case 1:
-        size += vn_sizeof_array_size(4);
-    size += vn_sizeof_int32_t_array(val->int32, 4);
-        break;
-    case 2:
-        size += vn_sizeof_array_size(4);
-    size += vn_sizeof_uint32_t_array(val->uint32, 4);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkClearColorValue(const VkClearColorValue *val)
-{
-    return vn_sizeof_VkClearColorValue_tag(val, 2);
-}
-
-static inline void
-vn_encode_VkClearColorValue_tag(struct vn_cs_encoder *enc, const VkClearColorValue *val, uint32_t tag)
-{
-    vn_encode_uint32_t(enc, &tag);
-    switch (tag) {
-    case 0:
-        vn_encode_array_size(enc, 4);
-    vn_encode_float_array(enc, val->float32, 4);
-        break;
-    case 1:
-        vn_encode_array_size(enc, 4);
-    vn_encode_int32_t_array(enc, val->int32, 4);
-        break;
-    case 2:
-        vn_encode_array_size(enc, 4);
-    vn_encode_uint32_t_array(enc, val->uint32, 4);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_encode_VkClearColorValue(struct vn_cs_encoder *enc, const VkClearColorValue *val)
-{
-    vn_encode_VkClearColorValue_tag(enc, val, 2); /* union with default tag */
-}
-
-/* struct VkClearDepthStencilValue */
-
-static inline size_t
-vn_sizeof_VkClearDepthStencilValue(const VkClearDepthStencilValue *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_float(&val->depth);
-    size += vn_sizeof_uint32_t(&val->stencil);
-    return size;
-}
-
-static inline void
-vn_encode_VkClearDepthStencilValue(struct vn_cs_encoder *enc, const VkClearDepthStencilValue *val)
-{
-    vn_encode_float(enc, &val->depth);
-    vn_encode_uint32_t(enc, &val->stencil);
-}
-
-/* union VkClearValue */
-
-static inline size_t
-vn_sizeof_VkClearValue_tag(const VkClearValue *val, uint32_t tag)
-{
-    size_t size = vn_sizeof_uint32_t(&tag);
-    switch (tag) {
-    case 0:
-        size += vn_sizeof_VkClearColorValue(&val->color);
-        break;
-    case 1:
-        size += vn_sizeof_VkClearDepthStencilValue(&val->depthStencil);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkClearValue(const VkClearValue *val)
-{
-    return vn_sizeof_VkClearValue_tag(val, 0);
-}
-
-static inline void
-vn_encode_VkClearValue_tag(struct vn_cs_encoder *enc, const VkClearValue *val, uint32_t tag)
-{
-    vn_encode_uint32_t(enc, &tag);
-    switch (tag) {
-    case 0:
-        vn_encode_VkClearColorValue(enc, &val->color);
-        break;
-    case 1:
-        vn_encode_VkClearDepthStencilValue(enc, &val->depthStencil);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_encode_VkClearValue(struct vn_cs_encoder *enc, const VkClearValue *val)
-{
-    vn_encode_VkClearValue_tag(enc, val, 0); /* union with default tag */
-}
-
-/* struct VkDeviceGroupRenderPassBeginInfo chain */
-
-static inline size_t
-vn_sizeof_VkDeviceGroupRenderPassBeginInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDeviceGroupRenderPassBeginInfo_self(const VkDeviceGroupRenderPassBeginInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->deviceMask);
-    size += vn_sizeof_uint32_t(&val->deviceRenderAreaCount);
-    if (val->pDeviceRenderAreas) {
-        size += vn_sizeof_array_size(val->deviceRenderAreaCount);
-        for (uint32_t i = 0; i < val->deviceRenderAreaCount; i++)
-            size += vn_sizeof_VkRect2D(&val->pDeviceRenderAreas[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDeviceGroupRenderPassBeginInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDeviceGroupRenderPassBeginInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDeviceGroupRenderPassBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDeviceGroupRenderPassBeginInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupRenderPassBeginInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->deviceMask);
-    vn_encode_uint32_t(enc, &val->deviceRenderAreaCount);
-    if (val->pDeviceRenderAreas) {
-        vn_encode_array_size(enc, val->deviceRenderAreaCount);
-        for (uint32_t i = 0; i < val->deviceRenderAreaCount; i++)
-            vn_encode_VkRect2D(enc, &val->pDeviceRenderAreas[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkDeviceGroupRenderPassBeginInfo(struct vn_cs_encoder *enc, const VkDeviceGroupRenderPassBeginInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO });
-    vn_encode_VkDeviceGroupRenderPassBeginInfo_pnext(enc, val->pNext);
-    vn_encode_VkDeviceGroupRenderPassBeginInfo_self(enc, val);
-}
-
-/* struct VkRenderPassAttachmentBeginInfo chain */
-
-static inline size_t
-vn_sizeof_VkRenderPassAttachmentBeginInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkRenderPassAttachmentBeginInfo_self(const VkRenderPassAttachmentBeginInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->attachmentCount);
-    if (val->pAttachments) {
-        size += vn_sizeof_array_size(val->attachmentCount);
-        for (uint32_t i = 0; i < val->attachmentCount; i++)
-            size += vn_sizeof_VkImageView(&val->pAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkRenderPassAttachmentBeginInfo_pnext(val->pNext);
-    size += vn_sizeof_VkRenderPassAttachmentBeginInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkRenderPassAttachmentBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkRenderPassAttachmentBeginInfo_self(struct vn_cs_encoder *enc, const VkRenderPassAttachmentBeginInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->attachmentCount);
-    if (val->pAttachments) {
-        vn_encode_array_size(enc, val->attachmentCount);
-        for (uint32_t i = 0; i < val->attachmentCount; i++)
-            vn_encode_VkImageView(enc, &val->pAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkRenderPassAttachmentBeginInfo(struct vn_cs_encoder *enc, const VkRenderPassAttachmentBeginInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO });
-    vn_encode_VkRenderPassAttachmentBeginInfo_pnext(enc, val->pNext);
-    vn_encode_VkRenderPassAttachmentBeginInfo_self(enc, val);
-}
-
-/* struct VkRenderPassBeginInfo chain */
-
-static inline size_t
-vn_sizeof_VkRenderPassBeginInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkRenderPassBeginInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkDeviceGroupRenderPassBeginInfo_self((const VkDeviceGroupRenderPassBeginInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkRenderPassBeginInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkRenderPassAttachmentBeginInfo_self((const VkRenderPassAttachmentBeginInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkRenderPassBeginInfo_self(const VkRenderPassBeginInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkRenderPass(&val->renderPass);
-    size += vn_sizeof_VkFramebuffer(&val->framebuffer);
-    size += vn_sizeof_VkRect2D(&val->renderArea);
-    size += vn_sizeof_uint32_t(&val->clearValueCount);
-    if (val->pClearValues) {
-        size += vn_sizeof_array_size(val->clearValueCount);
-        for (uint32_t i = 0; i < val->clearValueCount; i++)
-            size += vn_sizeof_VkClearValue(&val->pClearValues[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkRenderPassBeginInfo(const VkRenderPassBeginInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkRenderPassBeginInfo_pnext(val->pNext);
-    size += vn_sizeof_VkRenderPassBeginInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkRenderPassBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkRenderPassBeginInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkDeviceGroupRenderPassBeginInfo_self(enc, (const VkDeviceGroupRenderPassBeginInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkRenderPassBeginInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkRenderPassAttachmentBeginInfo_self(enc, (const VkRenderPassAttachmentBeginInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkRenderPassBeginInfo_self(struct vn_cs_encoder *enc, const VkRenderPassBeginInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkRenderPass(enc, &val->renderPass);
-    vn_encode_VkFramebuffer(enc, &val->framebuffer);
-    vn_encode_VkRect2D(enc, &val->renderArea);
-    vn_encode_uint32_t(enc, &val->clearValueCount);
-    if (val->pClearValues) {
-        vn_encode_array_size(enc, val->clearValueCount);
-        for (uint32_t i = 0; i < val->clearValueCount; i++)
-            vn_encode_VkClearValue(enc, &val->pClearValues[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkRenderPassBeginInfo(struct vn_cs_encoder *enc, const VkRenderPassBeginInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO });
-    vn_encode_VkRenderPassBeginInfo_pnext(enc, val->pNext);
-    vn_encode_VkRenderPassBeginInfo_self(enc, val);
-}
-
-/* struct VkClearAttachment */
-
-static inline size_t
-vn_sizeof_VkClearAttachment(const VkClearAttachment *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->aspectMask);
-    size += vn_sizeof_uint32_t(&val->colorAttachment);
-    size += vn_sizeof_VkClearValue(&val->clearValue);
-    return size;
-}
-
-static inline void
-vn_encode_VkClearAttachment(struct vn_cs_encoder *enc, const VkClearAttachment *val)
-{
-    vn_encode_VkFlags(enc, &val->aspectMask);
-    vn_encode_uint32_t(enc, &val->colorAttachment);
-    vn_encode_VkClearValue(enc, &val->clearValue);
-}
-
-/* struct VkAttachmentDescription */
-
-static inline size_t
-vn_sizeof_VkAttachmentDescription(const VkAttachmentDescription *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkFormat(&val->format);
-    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
-    size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp);
-    size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp);
-    size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp);
-    size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp);
-    size += vn_sizeof_VkImageLayout(&val->initialLayout);
-    size += vn_sizeof_VkImageLayout(&val->finalLayout);
-    return size;
-}
-
-static inline void
-vn_encode_VkAttachmentDescription(struct vn_cs_encoder *enc, const VkAttachmentDescription *val)
-{
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkFormat(enc, &val->format);
-    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
-    vn_encode_VkAttachmentLoadOp(enc, &val->loadOp);
-    vn_encode_VkAttachmentStoreOp(enc, &val->storeOp);
-    vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp);
-    vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp);
-    vn_encode_VkImageLayout(enc, &val->initialLayout);
-    vn_encode_VkImageLayout(enc, &val->finalLayout);
-}
-
-/* struct VkAttachmentReference */
-
-static inline size_t
-vn_sizeof_VkAttachmentReference(const VkAttachmentReference *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->attachment);
-    size += vn_sizeof_VkImageLayout(&val->layout);
-    return size;
-}
-
-static inline void
-vn_encode_VkAttachmentReference(struct vn_cs_encoder *enc, const VkAttachmentReference *val)
-{
-    vn_encode_uint32_t(enc, &val->attachment);
-    vn_encode_VkImageLayout(enc, &val->layout);
-}
-
-/* struct VkSubpassDescription */
-
-static inline size_t
-vn_sizeof_VkSubpassDescription(const VkSubpassDescription *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);
-    size += vn_sizeof_uint32_t(&val->inputAttachmentCount);
-    if (val->pInputAttachments) {
-        size += vn_sizeof_array_size(val->inputAttachmentCount);
-        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
-            size += vn_sizeof_VkAttachmentReference(&val->pInputAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
-    if (val->pColorAttachments) {
-        size += vn_sizeof_array_size(val->colorAttachmentCount);
-        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
-            size += vn_sizeof_VkAttachmentReference(&val->pColorAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    if (val->pResolveAttachments) {
-        size += vn_sizeof_array_size(val->colorAttachmentCount);
-        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
-            size += vn_sizeof_VkAttachmentReference(&val->pResolveAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment);
-    if (val->pDepthStencilAttachment)
-        size += vn_sizeof_VkAttachmentReference(val->pDepthStencilAttachment);
-    size += vn_sizeof_uint32_t(&val->preserveAttachmentCount);
-    if (val->pPreserveAttachments) {
-        size += vn_sizeof_array_size(val->preserveAttachmentCount);
-        size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline void
-vn_encode_VkSubpassDescription(struct vn_cs_encoder *enc, const VkSubpassDescription *val)
-{
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);
-    vn_encode_uint32_t(enc, &val->inputAttachmentCount);
-    if (val->pInputAttachments) {
-        vn_encode_array_size(enc, val->inputAttachmentCount);
-        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
-            vn_encode_VkAttachmentReference(enc, &val->pInputAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->colorAttachmentCount);
-    if (val->pColorAttachments) {
-        vn_encode_array_size(enc, val->colorAttachmentCount);
-        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
-            vn_encode_VkAttachmentReference(enc, &val->pColorAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (val->pResolveAttachments) {
-        vn_encode_array_size(enc, val->colorAttachmentCount);
-        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
-            vn_encode_VkAttachmentReference(enc, &val->pResolveAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment))
-        vn_encode_VkAttachmentReference(enc, val->pDepthStencilAttachment);
-    vn_encode_uint32_t(enc, &val->preserveAttachmentCount);
-    if (val->pPreserveAttachments) {
-        vn_encode_array_size(enc, val->preserveAttachmentCount);
-        vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-/* struct VkSubpassDependency */
-
-static inline size_t
-vn_sizeof_VkSubpassDependency(const VkSubpassDependency *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->srcSubpass);
-    size += vn_sizeof_uint32_t(&val->dstSubpass);
-    size += vn_sizeof_VkFlags(&val->srcStageMask);
-    size += vn_sizeof_VkFlags(&val->dstStageMask);
-    size += vn_sizeof_VkFlags(&val->srcAccessMask);
-    size += vn_sizeof_VkFlags(&val->dstAccessMask);
-    size += vn_sizeof_VkFlags(&val->dependencyFlags);
-    return size;
-}
-
-static inline void
-vn_encode_VkSubpassDependency(struct vn_cs_encoder *enc, const VkSubpassDependency *val)
-{
-    vn_encode_uint32_t(enc, &val->srcSubpass);
-    vn_encode_uint32_t(enc, &val->dstSubpass);
-    vn_encode_VkFlags(enc, &val->srcStageMask);
-    vn_encode_VkFlags(enc, &val->dstStageMask);
-    vn_encode_VkFlags(enc, &val->srcAccessMask);
-    vn_encode_VkFlags(enc, &val->dstAccessMask);
-    vn_encode_VkFlags(enc, &val->dependencyFlags);
-}
-
-/* struct VkRenderPassMultiviewCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkRenderPassMultiviewCreateInfo_self(const VkRenderPassMultiviewCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->subpassCount);
-    if (val->pViewMasks) {
-        size += vn_sizeof_array_size(val->subpassCount);
-        size += vn_sizeof_uint32_t_array(val->pViewMasks, val->subpassCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->dependencyCount);
-    if (val->pViewOffsets) {
-        size += vn_sizeof_array_size(val->dependencyCount);
-        size += vn_sizeof_int32_t_array(val->pViewOffsets, val->dependencyCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->correlationMaskCount);
-    if (val->pCorrelationMasks) {
-        size += vn_sizeof_array_size(val->correlationMaskCount);
-        size += vn_sizeof_uint32_t_array(val->pCorrelationMasks, val->correlationMaskCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkRenderPassMultiviewCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkRenderPassMultiviewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkRenderPassMultiviewCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassMultiviewCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->subpassCount);
-    if (val->pViewMasks) {
-        vn_encode_array_size(enc, val->subpassCount);
-        vn_encode_uint32_t_array(enc, val->pViewMasks, val->subpassCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->dependencyCount);
-    if (val->pViewOffsets) {
-        vn_encode_array_size(enc, val->dependencyCount);
-        vn_encode_int32_t_array(enc, val->pViewOffsets, val->dependencyCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->correlationMaskCount);
-    if (val->pCorrelationMasks) {
-        vn_encode_array_size(enc, val->correlationMaskCount);
-        vn_encode_uint32_t_array(enc, val->pCorrelationMasks, val->correlationMaskCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkRenderPassMultiviewCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassMultiviewCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO });
-    vn_encode_VkRenderPassMultiviewCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkRenderPassMultiviewCreateInfo_self(enc, val);
-}
-
-/* struct VkInputAttachmentAspectReference */
-
-static inline size_t
-vn_sizeof_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->subpass);
-    size += vn_sizeof_uint32_t(&val->inputAttachmentIndex);
-    size += vn_sizeof_VkFlags(&val->aspectMask);
-    return size;
-}
-
-static inline void
-vn_encode_VkInputAttachmentAspectReference(struct vn_cs_encoder *enc, const VkInputAttachmentAspectReference *val)
-{
-    vn_encode_uint32_t(enc, &val->subpass);
-    vn_encode_uint32_t(enc, &val->inputAttachmentIndex);
-    vn_encode_VkFlags(enc, &val->aspectMask);
-}
-
-/* struct VkRenderPassInputAttachmentAspectCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(const VkRenderPassInputAttachmentAspectCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->aspectReferenceCount);
-    if (val->pAspectReferences) {
-        size += vn_sizeof_array_size(val->aspectReferenceCount);
-        for (uint32_t i = 0; i < val->aspectReferenceCount; i++)
-            size += vn_sizeof_VkInputAttachmentAspectReference(&val->pAspectReferences[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassInputAttachmentAspectCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->aspectReferenceCount);
-    if (val->pAspectReferences) {
-        vn_encode_array_size(enc, val->aspectReferenceCount);
-        for (uint32_t i = 0; i < val->aspectReferenceCount; i++)
-            vn_encode_VkInputAttachmentAspectReference(enc, &val->pAspectReferences[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkRenderPassInputAttachmentAspectCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassInputAttachmentAspectCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO });
-    vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(enc, val);
-}
-
-/* struct VkRenderPassCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkRenderPassCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkRenderPassCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkRenderPassMultiviewCreateInfo_self((const VkRenderPassMultiviewCreateInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkRenderPassCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self((const VkRenderPassInputAttachmentAspectCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkRenderPassCreateInfo_self(const VkRenderPassCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->attachmentCount);
-    if (val->pAttachments) {
-        size += vn_sizeof_array_size(val->attachmentCount);
-        for (uint32_t i = 0; i < val->attachmentCount; i++)
-            size += vn_sizeof_VkAttachmentDescription(&val->pAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->subpassCount);
-    if (val->pSubpasses) {
-        size += vn_sizeof_array_size(val->subpassCount);
-        for (uint32_t i = 0; i < val->subpassCount; i++)
-            size += vn_sizeof_VkSubpassDescription(&val->pSubpasses[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->dependencyCount);
-    if (val->pDependencies) {
-        size += vn_sizeof_array_size(val->dependencyCount);
-        for (uint32_t i = 0; i < val->dependencyCount; i++)
-            size += vn_sizeof_VkSubpassDependency(&val->pDependencies[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkRenderPassCreateInfo(const VkRenderPassCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkRenderPassCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkRenderPassCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkRenderPassCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkRenderPassCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkRenderPassMultiviewCreateInfo_self(enc, (const VkRenderPassMultiviewCreateInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkRenderPassCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(enc, (const VkRenderPassInputAttachmentAspectCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkRenderPassCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->attachmentCount);
-    if (val->pAttachments) {
-        vn_encode_array_size(enc, val->attachmentCount);
-        for (uint32_t i = 0; i < val->attachmentCount; i++)
-            vn_encode_VkAttachmentDescription(enc, &val->pAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->subpassCount);
-    if (val->pSubpasses) {
-        vn_encode_array_size(enc, val->subpassCount);
-        for (uint32_t i = 0; i < val->subpassCount; i++)
-            vn_encode_VkSubpassDescription(enc, &val->pSubpasses[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->dependencyCount);
-    if (val->pDependencies) {
-        vn_encode_array_size(enc, val->dependencyCount);
-        for (uint32_t i = 0; i < val->dependencyCount; i++)
-            vn_encode_VkSubpassDependency(enc, &val->pDependencies[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkRenderPassCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO });
-    vn_encode_VkRenderPassCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkRenderPassCreateInfo_self(enc, val);
-}
-
-/* struct VkEventCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkEventCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkEventCreateInfo_self(const VkEventCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkEventCreateInfo(const VkEventCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkEventCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkEventCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkEventCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkEventCreateInfo_self(struct vn_cs_encoder *enc, const VkEventCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-}
-
-static inline void
-vn_encode_VkEventCreateInfo(struct vn_cs_encoder *enc, const VkEventCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO });
-    vn_encode_VkEventCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkEventCreateInfo_self(enc, val);
-}
-
-/* struct VkExportFenceCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkExportFenceCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExportFenceCreateInfo_self(const VkExportFenceCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->handleTypes);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExportFenceCreateInfo(const VkExportFenceCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExportFenceCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkExportFenceCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkExportFenceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkExportFenceCreateInfo_self(struct vn_cs_encoder *enc, const VkExportFenceCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->handleTypes);
-}
-
-static inline void
-vn_encode_VkExportFenceCreateInfo(struct vn_cs_encoder *enc, const VkExportFenceCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO });
-    vn_encode_VkExportFenceCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkExportFenceCreateInfo_self(enc, val);
-}
-
-/* struct VkFenceCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkFenceCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkFenceCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkExportFenceCreateInfo_self((const VkExportFenceCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkFenceCreateInfo_self(const VkFenceCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkFenceCreateInfo(const VkFenceCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkFenceCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkFenceCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkFenceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkFenceCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkExportFenceCreateInfo_self(enc, (const VkExportFenceCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkFenceCreateInfo_self(struct vn_cs_encoder *enc, const VkFenceCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-}
-
-static inline void
-vn_encode_VkFenceCreateInfo(struct vn_cs_encoder *enc, const VkFenceCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO });
-    vn_encode_VkFenceCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkFenceCreateInfo_self(enc, val);
-}
-
-/* struct VkExportSemaphoreCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkExportSemaphoreCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExportSemaphoreCreateInfo_self(const VkExportSemaphoreCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->handleTypes);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExportSemaphoreCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkExportSemaphoreCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkExportSemaphoreCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkExportSemaphoreCreateInfo_self(struct vn_cs_encoder *enc, const VkExportSemaphoreCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->handleTypes);
-}
-
-static inline void
-vn_encode_VkExportSemaphoreCreateInfo(struct vn_cs_encoder *enc, const VkExportSemaphoreCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO });
-    vn_encode_VkExportSemaphoreCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkExportSemaphoreCreateInfo_self(enc, val);
-}
-
-/* struct VkSemaphoreTypeCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkSemaphoreTypeCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSemaphoreTypeCreateInfo_self(const VkSemaphoreTypeCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkSemaphoreType(&val->semaphoreType);
-    size += vn_sizeof_uint64_t(&val->initialValue);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSemaphoreTypeCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSemaphoreTypeCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSemaphoreTypeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSemaphoreTypeCreateInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreTypeCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkSemaphoreType(enc, &val->semaphoreType);
-    vn_encode_uint64_t(enc, &val->initialValue);
-}
-
-static inline void
-vn_encode_VkSemaphoreTypeCreateInfo(struct vn_cs_encoder *enc, const VkSemaphoreTypeCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO });
-    vn_encode_VkSemaphoreTypeCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkSemaphoreTypeCreateInfo_self(enc, val);
-}
-
-/* struct VkSemaphoreCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkSemaphoreCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkSemaphoreCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkExportSemaphoreCreateInfo_self((const VkExportSemaphoreCreateInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkSemaphoreCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSemaphoreCreateInfo_self(const VkSemaphoreCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSemaphoreCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSemaphoreCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSemaphoreCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkSemaphoreCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkExportSemaphoreCreateInfo_self(enc, (const VkExportSemaphoreCreateInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkSemaphoreCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSemaphoreCreateInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-}
-
-static inline void
-vn_encode_VkSemaphoreCreateInfo(struct vn_cs_encoder *enc, const VkSemaphoreCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO });
-    vn_encode_VkSemaphoreCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkSemaphoreCreateInfo_self(enc, val);
-}
-
-/* struct VkQueryPoolCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkQueryPoolCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkQueryPoolCreateInfo_self(const VkQueryPoolCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkQueryType(&val->queryType);
-    size += vn_sizeof_uint32_t(&val->queryCount);
-    size += vn_sizeof_VkFlags(&val->pipelineStatistics);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkQueryPoolCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkQueryPoolCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkQueryPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkQueryPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkQueryPoolCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkQueryType(enc, &val->queryType);
-    vn_encode_uint32_t(enc, &val->queryCount);
-    vn_encode_VkFlags(enc, &val->pipelineStatistics);
-}
-
-static inline void
-vn_encode_VkQueryPoolCreateInfo(struct vn_cs_encoder *enc, const VkQueryPoolCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO });
-    vn_encode_VkQueryPoolCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkQueryPoolCreateInfo_self(enc, val);
-}
-
-/* struct VkFramebufferAttachmentImageInfo chain */
-
-static inline size_t
-vn_sizeof_VkFramebufferAttachmentImageInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkFramebufferAttachmentImageInfo_self(const VkFramebufferAttachmentImageInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkFlags(&val->usage);
-    size += vn_sizeof_uint32_t(&val->width);
-    size += vn_sizeof_uint32_t(&val->height);
-    size += vn_sizeof_uint32_t(&val->layerCount);
-    size += vn_sizeof_uint32_t(&val->viewFormatCount);
-    if (val->pViewFormats) {
-        size += vn_sizeof_array_size(val->viewFormatCount);
-        size += vn_sizeof_VkFormat_array(val->pViewFormats, val->viewFormatCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkFramebufferAttachmentImageInfo_pnext(val->pNext);
-    size += vn_sizeof_VkFramebufferAttachmentImageInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkFramebufferAttachmentImageInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkFramebufferAttachmentImageInfo_self(struct vn_cs_encoder *enc, const VkFramebufferAttachmentImageInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkFlags(enc, &val->usage);
-    vn_encode_uint32_t(enc, &val->width);
-    vn_encode_uint32_t(enc, &val->height);
-    vn_encode_uint32_t(enc, &val->layerCount);
-    vn_encode_uint32_t(enc, &val->viewFormatCount);
-    if (val->pViewFormats) {
-        vn_encode_array_size(enc, val->viewFormatCount);
-        vn_encode_VkFormat_array(enc, val->pViewFormats, val->viewFormatCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkFramebufferAttachmentImageInfo(struct vn_cs_encoder *enc, const VkFramebufferAttachmentImageInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO });
-    vn_encode_VkFramebufferAttachmentImageInfo_pnext(enc, val->pNext);
-    vn_encode_VkFramebufferAttachmentImageInfo_self(enc, val);
-}
-
-/* struct VkFramebufferAttachmentsCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkFramebufferAttachmentsCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkFramebufferAttachmentsCreateInfo_self(const VkFramebufferAttachmentsCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->attachmentImageInfoCount);
-    if (val->pAttachmentImageInfos) {
-        size += vn_sizeof_array_size(val->attachmentImageInfoCount);
-        for (uint32_t i = 0; i < val->attachmentImageInfoCount; i++)
-            size += vn_sizeof_VkFramebufferAttachmentImageInfo(&val->pAttachmentImageInfos[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkFramebufferAttachmentsCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkFramebufferAttachmentsCreateInfo_self(struct vn_cs_encoder *enc, const VkFramebufferAttachmentsCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->attachmentImageInfoCount);
-    if (val->pAttachmentImageInfos) {
-        vn_encode_array_size(enc, val->attachmentImageInfoCount);
-        for (uint32_t i = 0; i < val->attachmentImageInfoCount; i++)
-            vn_encode_VkFramebufferAttachmentImageInfo(enc, &val->pAttachmentImageInfos[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkFramebufferAttachmentsCreateInfo(struct vn_cs_encoder *enc, const VkFramebufferAttachmentsCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO });
-    vn_encode_VkFramebufferAttachmentsCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkFramebufferAttachmentsCreateInfo_self(enc, val);
-}
-
-/* struct VkFramebufferCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkFramebufferCreateInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkFramebufferCreateInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_self((const VkFramebufferAttachmentsCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkFramebufferCreateInfo_self(const VkFramebufferCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkRenderPass(&val->renderPass);
-    size += vn_sizeof_uint32_t(&val->attachmentCount);
-    if (val->pAttachments) {
-        size += vn_sizeof_array_size(val->attachmentCount);
-        for (uint32_t i = 0; i < val->attachmentCount; i++)
-            size += vn_sizeof_VkImageView(&val->pAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->width);
-    size += vn_sizeof_uint32_t(&val->height);
-    size += vn_sizeof_uint32_t(&val->layers);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkFramebufferCreateInfo(const VkFramebufferCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkFramebufferCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkFramebufferCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkFramebufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkFramebufferCreateInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkFramebufferAttachmentsCreateInfo_self(enc, (const VkFramebufferAttachmentsCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkFramebufferCreateInfo_self(struct vn_cs_encoder *enc, const VkFramebufferCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkRenderPass(enc, &val->renderPass);
-    vn_encode_uint32_t(enc, &val->attachmentCount);
-    if (val->pAttachments) {
-        vn_encode_array_size(enc, val->attachmentCount);
-        for (uint32_t i = 0; i < val->attachmentCount; i++)
-            vn_encode_VkImageView(enc, &val->pAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->width);
-    vn_encode_uint32_t(enc, &val->height);
-    vn_encode_uint32_t(enc, &val->layers);
-}
-
-static inline void
-vn_encode_VkFramebufferCreateInfo(struct vn_cs_encoder *enc, const VkFramebufferCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO });
-    vn_encode_VkFramebufferCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkFramebufferCreateInfo_self(enc, val);
-}
-
-/* struct VkDrawIndirectCommand */
-
-static inline size_t
-vn_sizeof_VkDrawIndirectCommand(const VkDrawIndirectCommand *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->vertexCount);
-    size += vn_sizeof_uint32_t(&val->instanceCount);
-    size += vn_sizeof_uint32_t(&val->firstVertex);
-    size += vn_sizeof_uint32_t(&val->firstInstance);
-    return size;
-}
-
-/* struct VkDrawIndexedIndirectCommand */
-
-static inline size_t
-vn_sizeof_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->indexCount);
-    size += vn_sizeof_uint32_t(&val->instanceCount);
-    size += vn_sizeof_uint32_t(&val->firstIndex);
-    size += vn_sizeof_int32_t(&val->vertexOffset);
-    size += vn_sizeof_uint32_t(&val->firstInstance);
-    return size;
-}
-
-/* struct VkDispatchIndirectCommand */
-
-static inline size_t
-vn_sizeof_VkDispatchIndirectCommand(const VkDispatchIndirectCommand *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->x);
-    size += vn_sizeof_uint32_t(&val->y);
-    size += vn_sizeof_uint32_t(&val->z);
-    return size;
-}
-
-/* struct VkDeviceGroupSubmitInfo chain */
-
-static inline size_t
-vn_sizeof_VkDeviceGroupSubmitInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDeviceGroupSubmitInfo_self(const VkDeviceGroupSubmitInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->waitSemaphoreCount);
-    if (val->pWaitSemaphoreDeviceIndices) {
-        size += vn_sizeof_array_size(val->waitSemaphoreCount);
-        size += vn_sizeof_uint32_t_array(val->pWaitSemaphoreDeviceIndices, val->waitSemaphoreCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->commandBufferCount);
-    if (val->pCommandBufferDeviceMasks) {
-        size += vn_sizeof_array_size(val->commandBufferCount);
-        size += vn_sizeof_uint32_t_array(val->pCommandBufferDeviceMasks, val->commandBufferCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->signalSemaphoreCount);
-    if (val->pSignalSemaphoreDeviceIndices) {
-        size += vn_sizeof_array_size(val->signalSemaphoreCount);
-        size += vn_sizeof_uint32_t_array(val->pSignalSemaphoreDeviceIndices, val->signalSemaphoreCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDeviceGroupSubmitInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDeviceGroupSubmitInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDeviceGroupSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDeviceGroupSubmitInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupSubmitInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->waitSemaphoreCount);
-    if (val->pWaitSemaphoreDeviceIndices) {
-        vn_encode_array_size(enc, val->waitSemaphoreCount);
-        vn_encode_uint32_t_array(enc, val->pWaitSemaphoreDeviceIndices, val->waitSemaphoreCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->commandBufferCount);
-    if (val->pCommandBufferDeviceMasks) {
-        vn_encode_array_size(enc, val->commandBufferCount);
-        vn_encode_uint32_t_array(enc, val->pCommandBufferDeviceMasks, val->commandBufferCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->signalSemaphoreCount);
-    if (val->pSignalSemaphoreDeviceIndices) {
-        vn_encode_array_size(enc, val->signalSemaphoreCount);
-        vn_encode_uint32_t_array(enc, val->pSignalSemaphoreDeviceIndices, val->signalSemaphoreCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkDeviceGroupSubmitInfo(struct vn_cs_encoder *enc, const VkDeviceGroupSubmitInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO });
-    vn_encode_VkDeviceGroupSubmitInfo_pnext(enc, val->pNext);
-    vn_encode_VkDeviceGroupSubmitInfo_self(enc, val);
-}
-
-/* struct VkProtectedSubmitInfo chain */
-
-static inline size_t
-vn_sizeof_VkProtectedSubmitInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkProtectedSubmitInfo_self(const VkProtectedSubmitInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->protectedSubmit);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkProtectedSubmitInfo(const VkProtectedSubmitInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkProtectedSubmitInfo_pnext(val->pNext);
-    size += vn_sizeof_VkProtectedSubmitInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkProtectedSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkProtectedSubmitInfo_self(struct vn_cs_encoder *enc, const VkProtectedSubmitInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBool32(enc, &val->protectedSubmit);
-}
-
-static inline void
-vn_encode_VkProtectedSubmitInfo(struct vn_cs_encoder *enc, const VkProtectedSubmitInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO });
-    vn_encode_VkProtectedSubmitInfo_pnext(enc, val->pNext);
-    vn_encode_VkProtectedSubmitInfo_self(enc, val);
-}
-
-/* struct VkSubmitInfo chain */
-
-static inline size_t
-vn_sizeof_VkSubmitInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkDeviceGroupSubmitInfo_self((const VkDeviceGroupSubmitInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkProtectedSubmitInfo_self((const VkProtectedSubmitInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self((const VkTimelineSemaphoreSubmitInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSubmitInfo_self(const VkSubmitInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->waitSemaphoreCount);
-    if (val->pWaitSemaphores) {
-        size += vn_sizeof_array_size(val->waitSemaphoreCount);
-        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
-            size += vn_sizeof_VkSemaphore(&val->pWaitSemaphores[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    if (val->pWaitDstStageMask) {
-        size += vn_sizeof_array_size(val->waitSemaphoreCount);
-        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
-            size += vn_sizeof_VkFlags(&val->pWaitDstStageMask[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->commandBufferCount);
-    if (val->pCommandBuffers) {
-        size += vn_sizeof_array_size(val->commandBufferCount);
-        for (uint32_t i = 0; i < val->commandBufferCount; i++)
-            size += vn_sizeof_VkCommandBuffer(&val->pCommandBuffers[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->signalSemaphoreCount);
-    if (val->pSignalSemaphores) {
-        size += vn_sizeof_array_size(val->signalSemaphoreCount);
-        for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
-            size += vn_sizeof_VkSemaphore(&val->pSignalSemaphores[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSubmitInfo(const VkSubmitInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSubmitInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSubmitInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkDeviceGroupSubmitInfo_self(enc, (const VkDeviceGroupSubmitInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkProtectedSubmitInfo_self(enc, (const VkProtectedSubmitInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, (const VkTimelineSemaphoreSubmitInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSubmitInfo_self(struct vn_cs_encoder *enc, const VkSubmitInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->waitSemaphoreCount);
-    if (val->pWaitSemaphores) {
-        vn_encode_array_size(enc, val->waitSemaphoreCount);
-        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
-            vn_encode_VkSemaphore(enc, &val->pWaitSemaphores[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (val->pWaitDstStageMask) {
-        vn_encode_array_size(enc, val->waitSemaphoreCount);
-        for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
-            vn_encode_VkFlags(enc, &val->pWaitDstStageMask[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->commandBufferCount);
-    if (val->pCommandBuffers) {
-        vn_encode_array_size(enc, val->commandBufferCount);
-        for (uint32_t i = 0; i < val->commandBufferCount; i++)
-            vn_encode_VkCommandBuffer(enc, &val->pCommandBuffers[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->signalSemaphoreCount);
-    if (val->pSignalSemaphores) {
-        vn_encode_array_size(enc, val->signalSemaphoreCount);
-        for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
-            vn_encode_VkSemaphore(enc, &val->pSignalSemaphores[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkSubmitInfo(struct vn_cs_encoder *enc, const VkSubmitInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SUBMIT_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBMIT_INFO });
-    vn_encode_VkSubmitInfo_pnext(enc, val->pNext);
-    vn_encode_VkSubmitInfo_self(enc, val);
-}
-
-/* struct VkConformanceVersion */
-
-static inline size_t
-vn_sizeof_VkConformanceVersion(const VkConformanceVersion *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint8_t(&val->major);
-    size += vn_sizeof_uint8_t(&val->minor);
-    size += vn_sizeof_uint8_t(&val->subminor);
-    size += vn_sizeof_uint8_t(&val->patch);
-    return size;
-}
-
-static inline void
-vn_decode_VkConformanceVersion(struct vn_cs_decoder *dec, VkConformanceVersion *val)
-{
-    vn_decode_uint8_t(dec, &val->major);
-    vn_decode_uint8_t(dec, &val->minor);
-    vn_decode_uint8_t(dec, &val->subminor);
-    vn_decode_uint8_t(dec, &val->patch);
-}
-
-static inline size_t
-vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion *val)
-{
-    size_t size = 0;
-    /* skip val->major */
-    /* skip val->minor */
-    /* skip val->subminor */
-    /* skip val->patch */
-    return size;
-}
-
-static inline void
-vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder *enc, const VkConformanceVersion *val)
-{
-    /* skip val->major */
-    /* skip val->minor */
-    /* skip val->subminor */
-    /* skip val->patch */
-}
-
-/* struct VkPhysicalDeviceDriverProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkDriverId(&val->driverID);
-    size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
-    size += vn_sizeof_blob_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
-    size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
-    size += vn_sizeof_blob_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
-    size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceDriverProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkDriverId(dec, &val->driverID);
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
-        vn_decode_blob_array(dec, val->driverName, array_size);
-    }
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
-        vn_decode_blob_array(dec, val->driverInfo, array_size);
-    }
-    vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceDriverProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceDriverProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->driverID */
-    /* skip val->driverName */
-    /* skip val->driverInfo */
-    size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->driverID */
-    /* skip val->driverName */
-    /* skip val->driverInfo */
-    vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES });
-    vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceIDProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_array_size(VK_UUID_SIZE);
-    size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
-    size += vn_sizeof_array_size(VK_UUID_SIZE);
-    size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
-    size += vn_sizeof_array_size(VK_LUID_SIZE);
-    size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
-    size += vn_sizeof_uint32_t(&val->deviceNodeMask);
-    size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceIDProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
-        vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
-    }
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
-        vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
-    }
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
-        vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
-    }
-    vn_decode_uint32_t(dec, &val->deviceNodeMask);
-    vn_decode_VkBool32(dec, &val->deviceLUIDValid);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceIDProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceIDProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->deviceUUID */
-    /* skip val->driverUUID */
-    /* skip val->deviceLUID */
-    /* skip val->deviceNodeMask */
-    /* skip val->deviceLUIDValid */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->deviceUUID */
-    /* skip val->driverUUID */
-    /* skip val->deviceLUID */
-    /* skip val->deviceNodeMask */
-    /* skip val->deviceLUIDValid */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES });
-    vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceMultiviewProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
-    size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
-    vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->maxMultiviewViewCount */
-    /* skip val->maxMultiviewInstanceIndex */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->maxMultiviewViewCount */
-    /* skip val->maxMultiviewInstanceIndex */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES });
-    vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceSubgroupProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->subgroupSize);
-    size += vn_sizeof_VkFlags(&val->supportedStages);
-    size += vn_sizeof_VkFlags(&val->supportedOperations);
-    size += vn_sizeof_VkBool32(&val->quadOperationsInAllStages);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->subgroupSize);
-    vn_decode_VkFlags(dec, &val->supportedStages);
-    vn_decode_VkFlags(dec, &val->supportedOperations);
-    vn_decode_VkBool32(dec, &val->quadOperationsInAllStages);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->subgroupSize */
-    /* skip val->supportedStages */
-    /* skip val->supportedOperations */
-    /* skip val->quadOperationsInAllStages */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->subgroupSize */
-    /* skip val->supportedStages */
-    /* skip val->supportedOperations */
-    /* skip val->quadOperationsInAllStages */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES });
-    vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDevicePointClippingProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
-}
-
-static inline void
-vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDevicePointClippingProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->pointClippingBehavior */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->pointClippingBehavior */
-}
-
-static inline void
-vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES });
-    vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceProtectedMemoryProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->protectedNoFault);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->protectedNoFault);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->protectedNoFault */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->protectedNoFault */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES });
-    vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceSamplerFilterMinmaxProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
-    size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
-    vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->filterMinmaxSingleComponentFormats */
-    /* skip val->filterMinmaxImageComponentMapping */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->filterMinmaxSingleComponentFormats */
-    /* skip val->filterMinmaxImageComponentMapping */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES });
-    vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceMaintenance3Properties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
-    size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
-    vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->maxPerSetDescriptors */
-    /* skip val->maxMemoryAllocationSize */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->maxPerSetDescriptors */
-    /* skip val->maxMemoryAllocationSize */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES });
-    vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceFloatControlsProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
-    size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
-    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
-    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
-    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
-    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
-    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
-    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
-    vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
-    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
-    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
-    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
-    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
-    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
-    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
-    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
-    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
-    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->denormBehaviorIndependence */
-    /* skip val->roundingModeIndependence */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
-    /* skip val->shaderDenormPreserveFloat16 */
-    /* skip val->shaderDenormPreserveFloat32 */
-    /* skip val->shaderDenormPreserveFloat64 */
-    /* skip val->shaderDenormFlushToZeroFloat16 */
-    /* skip val->shaderDenormFlushToZeroFloat32 */
-    /* skip val->shaderDenormFlushToZeroFloat64 */
-    /* skip val->shaderRoundingModeRTEFloat16 */
-    /* skip val->shaderRoundingModeRTEFloat32 */
-    /* skip val->shaderRoundingModeRTEFloat64 */
-    /* skip val->shaderRoundingModeRTZFloat16 */
-    /* skip val->shaderRoundingModeRTZFloat32 */
-    /* skip val->shaderRoundingModeRTZFloat64 */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->denormBehaviorIndependence */
-    /* skip val->roundingModeIndependence */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
-    /* skip val->shaderDenormPreserveFloat16 */
-    /* skip val->shaderDenormPreserveFloat32 */
-    /* skip val->shaderDenormPreserveFloat64 */
-    /* skip val->shaderDenormFlushToZeroFloat16 */
-    /* skip val->shaderDenormFlushToZeroFloat32 */
-    /* skip val->shaderDenormFlushToZeroFloat64 */
-    /* skip val->shaderRoundingModeRTEFloat16 */
-    /* skip val->shaderRoundingModeRTEFloat32 */
-    /* skip val->shaderRoundingModeRTEFloat64 */
-    /* skip val->shaderRoundingModeRTZFloat16 */
-    /* skip val->shaderRoundingModeRTZFloat32 */
-    /* skip val->shaderRoundingModeRTZFloat64 */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES });
-    vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceDescriptorIndexingProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
-    size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
-    size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
-    size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
-    size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
-    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
-    size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
-    size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
-    vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
-    vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
-    vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
-    vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
-    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
-    vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
-    vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
-    /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
-    /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
-    /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
-    /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
-    /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
-    /* skip val->robustBufferAccessUpdateAfterBind */
-    /* skip val->quadDivergentImplicitLod */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
-    /* skip val->maxPerStageUpdateAfterBindResources */
-    /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
-    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
-    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
-    /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
-    /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
-    /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
-    /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
-    /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
-    /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
-    /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
-    /* skip val->robustBufferAccessUpdateAfterBind */
-    /* skip val->quadDivergentImplicitLod */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
-    /* skip val->maxPerStageUpdateAfterBindResources */
-    /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
-    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
-    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
-    /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
-    /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES });
-    vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceTimelineSemaphoreProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->maxTimelineSemaphoreValueDifference */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->maxTimelineSemaphoreValueDifference */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES });
-    vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceDepthStencilResolveProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
-    size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
-    size += vn_sizeof_VkBool32(&val->independentResolveNone);
-    size += vn_sizeof_VkBool32(&val->independentResolve);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
-    vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
-    vn_decode_VkBool32(dec, &val->independentResolveNone);
-    vn_decode_VkBool32(dec, &val->independentResolve);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->supportedDepthResolveModes */
-    /* skip val->supportedStencilResolveModes */
-    /* skip val->independentResolveNone */
-    /* skip val->independentResolve */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->supportedDepthResolveModes */
-    /* skip val->supportedStencilResolveModes */
-    /* skip val->independentResolveNone */
-    /* skip val->independentResolve */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES });
-    vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceTransformFeedbackPropertiesEXT chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreams);
-    size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBuffers);
-    size += vn_sizeof_VkDeviceSize(&val->maxTransformFeedbackBufferSize);
-    size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreamDataSize);
-    size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataSize);
-    size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataStride);
-    size += vn_sizeof_VkBool32(&val->transformFeedbackQueries);
-    size += vn_sizeof_VkBool32(&val->transformFeedbackStreamsLinesTriangles);
-    size += vn_sizeof_VkBool32(&val->transformFeedbackRasterizationStreamSelect);
-    size += vn_sizeof_VkBool32(&val->transformFeedbackDraw);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreams);
-    vn_decode_uint32_t(dec, &val->maxTransformFeedbackBuffers);
-    vn_decode_VkDeviceSize(dec, &val->maxTransformFeedbackBufferSize);
-    vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreamDataSize);
-    vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataSize);
-    vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataStride);
-    vn_decode_VkBool32(dec, &val->transformFeedbackQueries);
-    vn_decode_VkBool32(dec, &val->transformFeedbackStreamsLinesTriangles);
-    vn_decode_VkBool32(dec, &val->transformFeedbackRasterizationStreamSelect);
-    vn_decode_VkBool32(dec, &val->transformFeedbackDraw);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->maxTransformFeedbackStreams */
-    /* skip val->maxTransformFeedbackBuffers */
-    /* skip val->maxTransformFeedbackBufferSize */
-    /* skip val->maxTransformFeedbackStreamDataSize */
-    /* skip val->maxTransformFeedbackBufferDataSize */
-    /* skip val->maxTransformFeedbackBufferDataStride */
-    /* skip val->transformFeedbackQueries */
-    /* skip val->transformFeedbackStreamsLinesTriangles */
-    /* skip val->transformFeedbackRasterizationStreamSelect */
-    /* skip val->transformFeedbackDraw */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->maxTransformFeedbackStreams */
-    /* skip val->maxTransformFeedbackBuffers */
-    /* skip val->maxTransformFeedbackBufferSize */
-    /* skip val->maxTransformFeedbackStreamDataSize */
-    /* skip val->maxTransformFeedbackBufferDataSize */
-    /* skip val->maxTransformFeedbackBufferDataStride */
-    /* skip val->transformFeedbackQueries */
-    /* skip val->transformFeedbackStreamsLinesTriangles */
-    /* skip val->transformFeedbackRasterizationStreamSelect */
-    /* skip val->transformFeedbackDraw */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT });
-    vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceVulkan11Properties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_array_size(VK_UUID_SIZE);
-    size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
-    size += vn_sizeof_array_size(VK_UUID_SIZE);
-    size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
-    size += vn_sizeof_array_size(VK_LUID_SIZE);
-    size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
-    size += vn_sizeof_uint32_t(&val->deviceNodeMask);
-    size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
-    size += vn_sizeof_uint32_t(&val->subgroupSize);
-    size += vn_sizeof_VkFlags(&val->subgroupSupportedStages);
-    size += vn_sizeof_VkFlags(&val->subgroupSupportedOperations);
-    size += vn_sizeof_VkBool32(&val->subgroupQuadOperationsInAllStages);
-    size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
-    size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
-    size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
-    size += vn_sizeof_VkBool32(&val->protectedNoFault);
-    size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
-    size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
-{
-    /* skip val->{sType,pNext} */
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
-        vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
-    }
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
-        vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
-    }
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
-        vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
-    }
-    vn_decode_uint32_t(dec, &val->deviceNodeMask);
-    vn_decode_VkBool32(dec, &val->deviceLUIDValid);
-    vn_decode_uint32_t(dec, &val->subgroupSize);
-    vn_decode_VkFlags(dec, &val->subgroupSupportedStages);
-    vn_decode_VkFlags(dec, &val->subgroupSupportedOperations);
-    vn_decode_VkBool32(dec, &val->subgroupQuadOperationsInAllStages);
-    vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
-    vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
-    vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
-    vn_decode_VkBool32(dec, &val->protectedNoFault);
-    vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
-    vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->deviceUUID */
-    /* skip val->driverUUID */
-    /* skip val->deviceLUID */
-    /* skip val->deviceNodeMask */
-    /* skip val->deviceLUIDValid */
-    /* skip val->subgroupSize */
-    /* skip val->subgroupSupportedStages */
-    /* skip val->subgroupSupportedOperations */
-    /* skip val->subgroupQuadOperationsInAllStages */
-    /* skip val->pointClippingBehavior */
-    /* skip val->maxMultiviewViewCount */
-    /* skip val->maxMultiviewInstanceIndex */
-    /* skip val->protectedNoFault */
-    /* skip val->maxPerSetDescriptors */
-    /* skip val->maxMemoryAllocationSize */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->deviceUUID */
-    /* skip val->driverUUID */
-    /* skip val->deviceLUID */
-    /* skip val->deviceNodeMask */
-    /* skip val->deviceLUIDValid */
-    /* skip val->subgroupSize */
-    /* skip val->subgroupSupportedStages */
-    /* skip val->subgroupSupportedOperations */
-    /* skip val->subgroupQuadOperationsInAllStages */
-    /* skip val->pointClippingBehavior */
-    /* skip val->maxMultiviewViewCount */
-    /* skip val->maxMultiviewInstanceIndex */
-    /* skip val->protectedNoFault */
-    /* skip val->maxPerSetDescriptors */
-    /* skip val->maxMemoryAllocationSize */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES });
-    vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceVulkan12Properties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkDriverId(&val->driverID);
-    size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
-    size += vn_sizeof_blob_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
-    size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
-    size += vn_sizeof_blob_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
-    size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
-    size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
-    size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
-    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
-    size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
-    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
-    size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
-    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
-    size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
-    size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
-    size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
-    size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
-    size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
-    size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
-    size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
-    size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
-    size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
-    size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
-    size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
-    size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
-    size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
-    size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
-    size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
-    size += vn_sizeof_VkBool32(&val->independentResolveNone);
-    size += vn_sizeof_VkBool32(&val->independentResolve);
-    size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
-    size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
-    size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
-    size += vn_sizeof_VkFlags(&val->framebufferIntegerColorSampleCounts);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkDriverId(dec, &val->driverID);
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
-        vn_decode_blob_array(dec, val->driverName, array_size);
-    }
-    {
-        const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
-        vn_decode_blob_array(dec, val->driverInfo, array_size);
-    }
-    vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
-    vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
-    vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
-    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
-    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
-    vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
-    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
-    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
-    vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
-    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
-    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
-    vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
-    vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
-    vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
-    vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
-    vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
-    vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
-    vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
-    vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
-    vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
-    vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
-    vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
-    vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
-    vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
-    vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
-    vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
-    vn_decode_VkBool32(dec, &val->independentResolveNone);
-    vn_decode_VkBool32(dec, &val->independentResolve);
-    vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
-    vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
-    vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
-    vn_decode_VkFlags(dec, &val->framebufferIntegerColorSampleCounts);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->driverID */
-    /* skip val->driverName */
-    /* skip val->driverInfo */
-    size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
-    /* skip val->denormBehaviorIndependence */
-    /* skip val->roundingModeIndependence */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
-    /* skip val->shaderDenormPreserveFloat16 */
-    /* skip val->shaderDenormPreserveFloat32 */
-    /* skip val->shaderDenormPreserveFloat64 */
-    /* skip val->shaderDenormFlushToZeroFloat16 */
-    /* skip val->shaderDenormFlushToZeroFloat32 */
-    /* skip val->shaderDenormFlushToZeroFloat64 */
-    /* skip val->shaderRoundingModeRTEFloat16 */
-    /* skip val->shaderRoundingModeRTEFloat32 */
-    /* skip val->shaderRoundingModeRTEFloat64 */
-    /* skip val->shaderRoundingModeRTZFloat16 */
-    /* skip val->shaderRoundingModeRTZFloat32 */
-    /* skip val->shaderRoundingModeRTZFloat64 */
-    /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
-    /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
-    /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
-    /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
-    /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
-    /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
-    /* skip val->robustBufferAccessUpdateAfterBind */
-    /* skip val->quadDivergentImplicitLod */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
-    /* skip val->maxPerStageUpdateAfterBindResources */
-    /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
-    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
-    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
-    /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
-    /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
-    /* skip val->supportedDepthResolveModes */
-    /* skip val->supportedStencilResolveModes */
-    /* skip val->independentResolveNone */
-    /* skip val->independentResolve */
-    /* skip val->filterMinmaxSingleComponentFormats */
-    /* skip val->filterMinmaxImageComponentMapping */
-    /* skip val->maxTimelineSemaphoreValueDifference */
-    /* skip val->framebufferIntegerColorSampleCounts */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->driverID */
-    /* skip val->driverName */
-    /* skip val->driverInfo */
-    vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
-    /* skip val->denormBehaviorIndependence */
-    /* skip val->roundingModeIndependence */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
-    /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
-    /* skip val->shaderDenormPreserveFloat16 */
-    /* skip val->shaderDenormPreserveFloat32 */
-    /* skip val->shaderDenormPreserveFloat64 */
-    /* skip val->shaderDenormFlushToZeroFloat16 */
-    /* skip val->shaderDenormFlushToZeroFloat32 */
-    /* skip val->shaderDenormFlushToZeroFloat64 */
-    /* skip val->shaderRoundingModeRTEFloat16 */
-    /* skip val->shaderRoundingModeRTEFloat32 */
-    /* skip val->shaderRoundingModeRTEFloat64 */
-    /* skip val->shaderRoundingModeRTZFloat16 */
-    /* skip val->shaderRoundingModeRTZFloat32 */
-    /* skip val->shaderRoundingModeRTZFloat64 */
-    /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
-    /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
-    /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
-    /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
-    /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
-    /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
-    /* skip val->robustBufferAccessUpdateAfterBind */
-    /* skip val->quadDivergentImplicitLod */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
-    /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
-    /* skip val->maxPerStageUpdateAfterBindResources */
-    /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
-    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
-    /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
-    /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
-    /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
-    /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
-    /* skip val->supportedDepthResolveModes */
-    /* skip val->supportedStencilResolveModes */
-    /* skip val->independentResolveNone */
-    /* skip val->independentResolve */
-    /* skip val->filterMinmaxSingleComponentFormats */
-    /* skip val->filterMinmaxImageComponentMapping */
-    /* skip val->maxTimelineSemaphoreValueDifference */
-    /* skip val->framebufferIntegerColorSampleCounts */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES });
-    vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceProperties2 chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceDriverProperties_self((const VkPhysicalDeviceDriverProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceIDProperties_self((const VkPhysicalDeviceIDProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self((const VkPhysicalDeviceMultiviewProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self((const VkPhysicalDeviceSubgroupProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self((const VkPhysicalDevicePointClippingProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self((const VkPhysicalDeviceMaintenance3Properties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self((const VkPhysicalDeviceFloatControlsProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self((const VkPhysicalDeviceVulkan11Properties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self((const VkPhysicalDeviceVulkan12Properties *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkPhysicalDeviceProperties(&val->properties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceProperties2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
-    VkStructureType stype;
-
-    if (!vn_decode_simple_pointer(dec))
-        return;
-
-    vn_decode_VkStructureType(dec, &stype);
-    while (true) {
-        assert(pnext);
-        if (pnext->sType == stype)
-            break;
-    }
-
-    switch ((int32_t)pnext->sType) {
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceDriverProperties_self(dec, (VkPhysicalDeviceDriverProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceIDProperties_self(dec, (VkPhysicalDeviceIDProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, (VkPhysicalDeviceMultiviewProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, (VkPhysicalDeviceSubgroupProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, (VkPhysicalDevicePointClippingProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, (VkPhysicalDeviceProtectedMemoryProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, (VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, (VkPhysicalDeviceMaintenance3Properties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, (VkPhysicalDeviceFloatControlsProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, (VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, (VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, (VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, (VkPhysicalDeviceVulkan11Properties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
-        vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, (VkPhysicalDeviceVulkan12Properties *)pnext);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkPhysicalDeviceProperties(dec, &val->properties);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceProperties2_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceProperties2_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial((const VkPhysicalDeviceDriverProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial((const VkPhysicalDeviceIDProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial((const VkPhysicalDeviceMultiviewProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial((const VkPhysicalDeviceSubgroupProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial((const VkPhysicalDevicePointClippingProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial((const VkPhysicalDeviceMaintenance3Properties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial((const VkPhysicalDeviceFloatControlsProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial((const VkPhysicalDeviceVulkan11Properties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial((const VkPhysicalDeviceVulkan12Properties *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkPhysicalDeviceProperties_partial(&val->properties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceProperties2_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, (const VkPhysicalDeviceDriverProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, (const VkPhysicalDeviceIDProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, (const VkPhysicalDeviceMultiviewProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, (const VkPhysicalDeviceSubgroupProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, (const VkPhysicalDevicePointClippingProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance3Properties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, (const VkPhysicalDeviceFloatControlsProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, (const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, (const VkPhysicalDeviceVulkan11Properties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, (const VkPhysicalDeviceVulkan12Properties *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkPhysicalDeviceProperties_partial(enc, &val->properties);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 });
-    vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceProperties2_self_partial(enc, val);
-}
-
-/* struct VkDrmFormatModifierPropertiesEXT */
-
-static inline size_t
-vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint64_t(&val->drmFormatModifier);
-    size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
-    size += vn_sizeof_VkFlags(&val->drmFormatModifierTilingFeatures);
-    return size;
-}
-
-static inline void
-vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesEXT *val)
-{
-    vn_decode_uint64_t(dec, &val->drmFormatModifier);
-    vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount);
-    vn_decode_VkFlags(dec, &val->drmFormatModifierTilingFeatures);
-}
-
-static inline size_t
-vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT *val)
-{
-    size_t size = 0;
-    /* skip val->drmFormatModifier */
-    /* skip val->drmFormatModifierPlaneCount */
-    /* skip val->drmFormatModifierTilingFeatures */
-    return size;
-}
-
-static inline void
-vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesEXT *val)
-{
-    /* skip val->drmFormatModifier */
-    /* skip val->drmFormatModifierPlaneCount */
-    /* skip val->drmFormatModifierTilingFeatures */
-}
-
-/* struct VkDrmFormatModifierPropertiesListEXT chain */
-
-static inline size_t
-vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
-    if (val->pDrmFormatModifierProperties) {
-        size += vn_sizeof_array_size(val->drmFormatModifierCount);
-        for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
-            size += vn_sizeof_VkDrmFormatModifierPropertiesEXT(&val->pDrmFormatModifierProperties[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(val->pNext);
-    size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->drmFormatModifierCount);
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, val->drmFormatModifierCount);
-        for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
-            vn_decode_VkDrmFormatModifierPropertiesEXT(dec, &val->pDrmFormatModifierProperties[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        val->pDrmFormatModifierProperties = NULL;
-    }
-}
-
-static inline void
-vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
-
-    assert(val->sType == stype);
-    vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(dec, val->pNext);
-    vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->drmFormatModifierCount */
-    if (val->pDrmFormatModifierProperties) {
-        size += vn_sizeof_array_size(val->drmFormatModifierCount);
-        for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
-            size += vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(&val->pDrmFormatModifierProperties[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(val->pNext);
-    size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->drmFormatModifierCount */
-    if (val->pDrmFormatModifierProperties) {
-        vn_encode_array_size(enc, val->drmFormatModifierCount);
-        for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
-            vn_encode_VkDrmFormatModifierPropertiesEXT_partial(enc, &val->pDrmFormatModifierProperties[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT });
-    vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(enc, val->pNext);
-    vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, val);
-}
-
-/* struct VkFormatProperties2 chain */
-
-static inline size_t
-vn_sizeof_VkFormatProperties2_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self((const VkDrmFormatModifierPropertiesListEXT *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFormatProperties(&val->formatProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkFormatProperties2(const VkFormatProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkFormatProperties2_pnext(val->pNext);
-    size += vn_sizeof_VkFormatProperties2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
-    VkStructureType stype;
-
-    if (!vn_decode_simple_pointer(dec))
-        return;
-
-    vn_decode_VkStructureType(dec, &stype);
-    while (true) {
-        assert(pnext);
-        if (pnext->sType == stype)
-            break;
-    }
-
-    switch ((int32_t)pnext->sType) {
-    case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
-        vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, (VkDrmFormatModifierPropertiesListEXT *)pnext);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_decode_VkFormatProperties2_self(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkFormatProperties(dec, &val->formatProperties);
-}
-
-static inline void
-vn_decode_VkFormatProperties2(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
-
-    assert(val->sType == stype);
-    vn_decode_VkFormatProperties2_pnext(dec, val->pNext);
-    vn_decode_VkFormatProperties2_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkFormatProperties2_pnext_partial(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial((const VkDrmFormatModifierPropertiesListEXT *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFormatProperties_partial(&val->formatProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkFormatProperties2_pnext_partial(val->pNext);
-    size += vn_sizeof_VkFormatProperties2_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, (const VkDrmFormatModifierPropertiesListEXT *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFormatProperties_partial(enc, &val->formatProperties);
-}
-
-static inline void
-vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 });
-    vn_encode_VkFormatProperties2_pnext_partial(enc, val->pNext);
-    vn_encode_VkFormatProperties2_self_partial(enc, val);
-}
-
-/* struct VkExternalMemoryProperties */
-
-static inline size_t
-vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_VkFlags(&val->externalMemoryFeatures);
-    size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
-    size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
-    return size;
-}
-
-static inline void
-vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder *dec, VkExternalMemoryProperties *val)
-{
-    vn_decode_VkFlags(dec, &val->externalMemoryFeatures);
-    vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
-    vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
-}
-
-static inline size_t
-vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties *val)
-{
-    size_t size = 0;
-    /* skip val->externalMemoryFeatures */
-    /* skip val->exportFromImportedHandleTypes */
-    /* skip val->compatibleHandleTypes */
-    return size;
-}
-
-static inline void
-vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder *enc, const VkExternalMemoryProperties *val)
-{
-    /* skip val->externalMemoryFeatures */
-    /* skip val->exportFromImportedHandleTypes */
-    /* skip val->compatibleHandleTypes */
-}
-
-/* struct VkExternalImageFormatProperties chain */
-
-static inline size_t
-vn_sizeof_VkExternalImageFormatProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExternalImageFormatProperties_pnext(val->pNext);
-    size += vn_sizeof_VkExternalImageFormatProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
-}
-
-static inline void
-vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkExternalImageFormatProperties_pnext(dec, val->pNext);
-    vn_decode_VkExternalImageFormatProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExternalImageFormatProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkExternalImageFormatProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
-}
-
-static inline void
-vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES });
-    vn_encode_VkExternalImageFormatProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkExternalImageFormatProperties_self_partial(enc, val);
-}
-
-/* struct VkSamplerYcbcrConversionImageFormatProperties chain */
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->combinedImageSamplerDescriptorCount);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(val->pNext);
-    size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->combinedImageSamplerDescriptorCount);
-}
-
-static inline void
-vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(dec, val->pNext);
-    vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->combinedImageSamplerDescriptorCount */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->combinedImageSamplerDescriptorCount */
-}
-
-static inline void
-vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES });
-    vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, val);
-}
-
-/* struct VkImageFormatProperties2 chain */
-
-static inline size_t
-vn_sizeof_VkImageFormatProperties2_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkExternalImageFormatProperties_self((const VkExternalImageFormatProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
-            size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkImageFormatProperties(&val->imageFormatProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageFormatProperties2_pnext(val->pNext);
-    size += vn_sizeof_VkImageFormatProperties2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
-    VkStructureType stype;
-
-    if (!vn_decode_simple_pointer(dec))
-        return;
-
-    vn_decode_VkStructureType(dec, &stype);
-    while (true) {
-        assert(pnext);
-        if (pnext->sType == stype)
-            break;
-    }
-
-    switch ((int32_t)pnext->sType) {
-    case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
-        vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkExternalImageFormatProperties_self(dec, (VkExternalImageFormatProperties *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
-        vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
-        vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, (VkSamplerYcbcrConversionImageFormatProperties *)pnext);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkImageFormatProperties(dec, &val->imageFormatProperties);
-}
-
-static inline void
-vn_decode_VkImageFormatProperties2(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
-
-    assert(val->sType == stype);
-    vn_decode_VkImageFormatProperties2_pnext(dec, val->pNext);
-    vn_decode_VkImageFormatProperties2_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkImageFormatProperties2_pnext_partial(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkExternalImageFormatProperties_self_partial((const VkExternalImageFormatProperties *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkImageFormatProperties_partial(&val->imageFormatProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageFormatProperties2_pnext_partial(val->pNext);
-    size += vn_sizeof_VkImageFormatProperties2_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkExternalImageFormatProperties_self_partial(enc, (const VkExternalImageFormatProperties *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, (const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkImageFormatProperties_partial(enc, &val->imageFormatProperties);
-}
-
-static inline void
-vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 });
-    vn_encode_VkImageFormatProperties2_pnext_partial(enc, val->pNext);
-    vn_encode_VkImageFormatProperties2_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceExternalImageFormatInfo chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO });
-    vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, val);
-}
-
-/* struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint64_t(&val->drmFormatModifier);
-    size += vn_sizeof_VkSharingMode(&val->sharingMode);
-    size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
-    if (val->pQueueFamilyIndices) {
-        size += vn_sizeof_array_size(val->queueFamilyIndexCount);
-        size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint64_t(enc, &val->drmFormatModifier);
-    vn_encode_VkSharingMode(enc, &val->sharingMode);
-    vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
-    if (val->pQueueFamilyIndices) {
-        vn_encode_array_size(enc, val->queueFamilyIndexCount);
-        vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT });
-    vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, val);
-}
-
-/* struct VkPhysicalDeviceImageFormatInfo2 chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self((const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
-            size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
-            size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self((const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
-            size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFormat(&val->format);
-    size += vn_sizeof_VkImageType(&val->type);
-    size += vn_sizeof_VkImageTiling(&val->tiling);
-    size += vn_sizeof_VkFlags(&val->usage);
-    size += vn_sizeof_VkFlags(&val->flags);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, (const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
-            vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
-            vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, (const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
-            vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFormat(enc, &val->format);
-    vn_encode_VkImageType(enc, &val->type);
-    vn_encode_VkImageTiling(enc, &val->tiling);
-    vn_encode_VkFlags(enc, &val->usage);
-    vn_encode_VkFlags(enc, &val->flags);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 });
-    vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceImageFormatInfo2_self(enc, val);
-}
-
-/* struct VkQueueFamilyProperties2 chain */
-
-static inline size_t
-vn_sizeof_VkQueueFamilyProperties2_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkQueueFamilyProperties(&val->queueFamilyProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkQueueFamilyProperties2_pnext(val->pNext);
-    size += vn_sizeof_VkQueueFamilyProperties2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkQueueFamilyProperties(dec, &val->queueFamilyProperties);
-}
-
-static inline void
-vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
-
-    assert(val->sType == stype);
-    vn_decode_VkQueueFamilyProperties2_pnext(dec, val->pNext);
-    vn_decode_VkQueueFamilyProperties2_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkQueueFamilyProperties_partial(&val->queueFamilyProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkQueueFamilyProperties2_pnext_partial(val->pNext);
-    size += vn_sizeof_VkQueueFamilyProperties2_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkQueueFamilyProperties_partial(enc, &val->queueFamilyProperties);
-}
-
-static inline void
-vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 });
-    vn_encode_VkQueueFamilyProperties2_pnext_partial(enc, val->pNext);
-    vn_encode_VkQueueFamilyProperties2_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceMemoryProperties2 chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkPhysicalDeviceMemoryProperties(&val->memoryProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkPhysicalDeviceMemoryProperties(dec, &val->memoryProperties);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceMemoryProperties2_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(&val->memoryProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, &val->memoryProperties);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 });
-    vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(enc, val);
-}
-
-/* struct VkSparseImageFormatProperties2 chain */
-
-static inline size_t
-vn_sizeof_VkSparseImageFormatProperties2_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkSparseImageFormatProperties(&val->properties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSparseImageFormatProperties2_pnext(val->pNext);
-    size += vn_sizeof_VkSparseImageFormatProperties2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkSparseImageFormatProperties(dec, &val->properties);
-}
-
-static inline void
-vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
-
-    assert(val->sType == stype);
-    vn_decode_VkSparseImageFormatProperties2_pnext(dec, val->pNext);
-    vn_decode_VkSparseImageFormatProperties2_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->properties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(val->pNext);
-    size += vn_sizeof_VkSparseImageFormatProperties2_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkSparseImageFormatProperties_partial(enc, &val->properties);
-}
-
-static inline void
-vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 });
-    vn_encode_VkSparseImageFormatProperties2_pnext_partial(enc, val->pNext);
-    vn_encode_VkSparseImageFormatProperties2_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceSparseImageFormatInfo2 chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFormat(&val->format);
-    size += vn_sizeof_VkImageType(&val->type);
-    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
-    size += vn_sizeof_VkFlags(&val->usage);
-    size += vn_sizeof_VkImageTiling(&val->tiling);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFormat(enc, &val->format);
-    vn_encode_VkImageType(enc, &val->type);
-    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
-    vn_encode_VkFlags(enc, &val->usage);
-    vn_encode_VkImageTiling(enc, &val->tiling);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 });
-    vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(enc, val);
-}
-
-/* struct VkPhysicalDeviceExternalBufferInfo chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkFlags(&val->usage);
-    size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkFlags(enc, &val->usage);
-    vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO });
-    vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceExternalBufferInfo_self(enc, val);
-}
-
-/* struct VkExternalBufferProperties chain */
-
-static inline size_t
-vn_sizeof_VkExternalBufferProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExternalBufferProperties_pnext(val->pNext);
-    size += vn_sizeof_VkExternalBufferProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
-}
-
-static inline void
-vn_decode_VkExternalBufferProperties(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkExternalBufferProperties_pnext(dec, val->pNext);
-    vn_decode_VkExternalBufferProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkExternalBufferProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExternalBufferProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkExternalBufferProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
-}
-
-static inline void
-vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES });
-    vn_encode_VkExternalBufferProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkExternalBufferProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceExternalSemaphoreInfo chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(&val->handleType);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkExternalSemaphoreHandleTypeFlagBits(enc, &val->handleType);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO });
-    vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(enc, val);
-}
-
-/* struct VkExternalSemaphoreProperties chain */
-
-static inline size_t
-vn_sizeof_VkExternalSemaphoreProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
-    size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
-    size += vn_sizeof_VkFlags(&val->externalSemaphoreFeatures);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExternalSemaphoreProperties_pnext(val->pNext);
-    size += vn_sizeof_VkExternalSemaphoreProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
-    vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
-    vn_decode_VkFlags(dec, &val->externalSemaphoreFeatures);
-}
-
-static inline void
-vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkExternalSemaphoreProperties_pnext(dec, val->pNext);
-    vn_decode_VkExternalSemaphoreProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->exportFromImportedHandleTypes */
-    /* skip val->compatibleHandleTypes */
-    /* skip val->externalSemaphoreFeatures */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkExternalSemaphoreProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->exportFromImportedHandleTypes */
-    /* skip val->compatibleHandleTypes */
-    /* skip val->externalSemaphoreFeatures */
-}
-
-static inline void
-vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES });
-    vn_encode_VkExternalSemaphoreProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkExternalSemaphoreProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceExternalFenceInfo chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkExternalFenceHandleTypeFlagBits(&val->handleType);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkExternalFenceHandleTypeFlagBits(enc, &val->handleType);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO });
-    vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceExternalFenceInfo_self(enc, val);
-}
-
-/* struct VkExternalFenceProperties chain */
-
-static inline size_t
-vn_sizeof_VkExternalFenceProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
-    size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
-    size += vn_sizeof_VkFlags(&val->externalFenceFeatures);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExternalFenceProperties_pnext(val->pNext);
-    size += vn_sizeof_VkExternalFenceProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
-    vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
-    vn_decode_VkFlags(dec, &val->externalFenceFeatures);
-}
-
-static inline void
-vn_decode_VkExternalFenceProperties(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkExternalFenceProperties_pnext(dec, val->pNext);
-    vn_decode_VkExternalFenceProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkExternalFenceProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->exportFromImportedHandleTypes */
-    /* skip val->compatibleHandleTypes */
-    /* skip val->externalFenceFeatures */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkExternalFenceProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkExternalFenceProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->exportFromImportedHandleTypes */
-    /* skip val->compatibleHandleTypes */
-    /* skip val->externalFenceFeatures */
-}
-
-static inline void
-vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES });
-    vn_encode_VkExternalFenceProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkExternalFenceProperties_self_partial(enc, val);
-}
-
-/* struct VkPhysicalDeviceGroupProperties chain */
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
-    size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
-    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
-        size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
-    size += vn_sizeof_VkBool32(&val->subsetAllocation);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceGroupProperties_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->physicalDeviceCount);
-    {
-        vn_decode_array_size(dec, VK_MAX_DEVICE_GROUP_SIZE);
-        for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
-            vn_decode_VkPhysicalDevice(dec, &val->physicalDevices[i]);
-    }
-    vn_decode_VkBool32(dec, &val->subsetAllocation);
-}
-
-static inline void
-vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
-
-    assert(val->sType == stype);
-    vn_decode_VkPhysicalDeviceGroupProperties_pnext(dec, val->pNext);
-    vn_decode_VkPhysicalDeviceGroupProperties_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->physicalDeviceCount */
-    size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
-    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
-        size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
-    /* skip val->subsetAllocation */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(val->pNext);
-    size += vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->physicalDeviceCount */
-    vn_encode_array_size(enc, VK_MAX_DEVICE_GROUP_SIZE);
-    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
-        vn_encode_VkPhysicalDevice(enc, &val->physicalDevices[i]);
-    /* skip val->subsetAllocation */
-}
-
-static inline void
-vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES });
-    vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(enc, val->pNext);
-    vn_encode_VkPhysicalDeviceGroupProperties_self_partial(enc, val);
-}
-
-/* struct VkBindBufferMemoryDeviceGroupInfo chain */
-
-static inline size_t
-vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_self(const VkBindBufferMemoryDeviceGroupInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->deviceIndexCount);
-    if (val->pDeviceIndices) {
-        size += vn_sizeof_array_size(val->deviceIndexCount);
-        size += vn_sizeof_uint32_t_array(val->pDeviceIndices, val->deviceIndexCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_pnext(val->pNext);
-    size += vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBindBufferMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBindBufferMemoryDeviceGroupInfo_self(struct vn_cs_encoder *enc, const VkBindBufferMemoryDeviceGroupInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->deviceIndexCount);
-    if (val->pDeviceIndices) {
-        vn_encode_array_size(enc, val->deviceIndexCount);
-        vn_encode_uint32_t_array(enc, val->pDeviceIndices, val->deviceIndexCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkBindBufferMemoryDeviceGroupInfo(struct vn_cs_encoder *enc, const VkBindBufferMemoryDeviceGroupInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO });
-    vn_encode_VkBindBufferMemoryDeviceGroupInfo_pnext(enc, val->pNext);
-    vn_encode_VkBindBufferMemoryDeviceGroupInfo_self(enc, val);
-}
-
-static inline void
-vn_decode_VkBindBufferMemoryDeviceGroupInfo_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkBindBufferMemoryDeviceGroupInfo_self(struct vn_cs_decoder *dec, VkBindBufferMemoryDeviceGroupInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->deviceIndexCount);
-    if (vn_peek_array_size(dec)) {
-        const size_t array_size = vn_decode_array_size(dec, val->deviceIndexCount);
-        vn_decode_uint32_t_array(dec, (uint32_t *)val->pDeviceIndices, array_size);
-    } else {
-        vn_decode_array_size(dec, 0);
-        val->pDeviceIndices = NULL;
-    }
-}
-
-static inline void
-vn_decode_VkBindBufferMemoryDeviceGroupInfo(struct vn_cs_decoder *dec, VkBindBufferMemoryDeviceGroupInfo *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO);
-
-    assert(val->sType == stype);
-    vn_decode_VkBindBufferMemoryDeviceGroupInfo_pnext(dec, val->pNext);
-    vn_decode_VkBindBufferMemoryDeviceGroupInfo_self(dec, val);
-}
-
-/* struct VkBindBufferMemoryInfo chain */
-
-static inline size_t
-vn_sizeof_VkBindBufferMemoryInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkBindBufferMemoryInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_self((const VkBindBufferMemoryDeviceGroupInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBindBufferMemoryInfo_self(const VkBindBufferMemoryInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBuffer(&val->buffer);
-    size += vn_sizeof_VkDeviceMemory(&val->memory);
-    size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBindBufferMemoryInfo_pnext(val->pNext);
-    size += vn_sizeof_VkBindBufferMemoryInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBindBufferMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkBindBufferMemoryInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkBindBufferMemoryDeviceGroupInfo_self(enc, (const VkBindBufferMemoryDeviceGroupInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBindBufferMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindBufferMemoryInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBuffer(enc, &val->buffer);
-    vn_encode_VkDeviceMemory(enc, &val->memory);
-    vn_encode_VkDeviceSize(enc, &val->memoryOffset);
-}
-
-static inline void
-vn_encode_VkBindBufferMemoryInfo(struct vn_cs_encoder *enc, const VkBindBufferMemoryInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO });
-    vn_encode_VkBindBufferMemoryInfo_pnext(enc, val->pNext);
-    vn_encode_VkBindBufferMemoryInfo_self(enc, val);
-}
-
-static inline void
-vn_decode_VkBindBufferMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
-    VkStructureType stype;
-
-    if (!vn_decode_simple_pointer(dec))
-        return;
-
-    vn_decode_VkStructureType(dec, &stype);
-    while (true) {
-        assert(pnext);
-        if (pnext->sType == stype)
-            break;
-    }
-
-    switch ((int32_t)pnext->sType) {
-    case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
-        vn_decode_VkBindBufferMemoryInfo_pnext(dec, pnext->pNext);
-        vn_decode_VkBindBufferMemoryDeviceGroupInfo_self(dec, (VkBindBufferMemoryDeviceGroupInfo *)pnext);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_decode_VkBindBufferMemoryInfo_self(struct vn_cs_decoder *dec, VkBindBufferMemoryInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBuffer(dec, &val->buffer);
-    vn_decode_VkDeviceMemory(dec, &val->memory);
-    vn_decode_VkDeviceSize(dec, &val->memoryOffset);
-}
-
-static inline void
-vn_decode_VkBindBufferMemoryInfo(struct vn_cs_decoder *dec, VkBindBufferMemoryInfo *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO);
-
-    assert(val->sType == stype);
-    vn_decode_VkBindBufferMemoryInfo_pnext(dec, val->pNext);
-    vn_decode_VkBindBufferMemoryInfo_self(dec, val);
-}
-
-/* struct VkBindImageMemoryDeviceGroupInfo chain */
-
-static inline size_t
-vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(const VkBindImageMemoryDeviceGroupInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->deviceIndexCount);
-    if (val->pDeviceIndices) {
-        size += vn_sizeof_array_size(val->deviceIndexCount);
-        size += vn_sizeof_uint32_t_array(val->pDeviceIndices, val->deviceIndexCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->splitInstanceBindRegionCount);
-    if (val->pSplitInstanceBindRegions) {
-        size += vn_sizeof_array_size(val->splitInstanceBindRegionCount);
-        for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
-            size += vn_sizeof_VkRect2D(&val->pSplitInstanceBindRegions[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(val->pNext);
-    size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->deviceIndexCount);
-    if (val->pDeviceIndices) {
-        vn_encode_array_size(enc, val->deviceIndexCount);
-        vn_encode_uint32_t_array(enc, val->pDeviceIndices, val->deviceIndexCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->splitInstanceBindRegionCount);
-    if (val->pSplitInstanceBindRegions) {
-        vn_encode_array_size(enc, val->splitInstanceBindRegionCount);
-        for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
-            vn_encode_VkRect2D(enc, &val->pSplitInstanceBindRegions[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-}
-
-static inline void
-vn_encode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO });
-    vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(enc, val->pNext);
-    vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, val);
-}
-
-static inline void
-vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->deviceIndexCount);
-    if (vn_peek_array_size(dec)) {
-        const size_t array_size = vn_decode_array_size(dec, val->deviceIndexCount);
-        vn_decode_uint32_t_array(dec, (uint32_t *)val->pDeviceIndices, array_size);
-    } else {
-        vn_decode_array_size(dec, 0);
-        val->pDeviceIndices = NULL;
-    }
-    vn_decode_uint32_t(dec, &val->splitInstanceBindRegionCount);
-    if (vn_peek_array_size(dec)) {
-        vn_decode_array_size(dec, val->splitInstanceBindRegionCount);
-        for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
-            vn_decode_VkRect2D(dec, &((VkRect2D *)val->pSplitInstanceBindRegions)[i]);
-    } else {
-        vn_decode_array_size(dec, 0);
-        val->pSplitInstanceBindRegions = NULL;
-    }
-}
-
-static inline void
-vn_decode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO);
-
-    assert(val->sType == stype);
-    vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext(dec, val->pNext);
-    vn_decode_VkBindImageMemoryDeviceGroupInfo_self(dec, val);
-}
-
-/* struct VkBindImagePlaneMemoryInfo chain */
-
-static inline size_t
-vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBindImagePlaneMemoryInfo_self(const VkBindImagePlaneMemoryInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(val->pNext);
-    size += vn_sizeof_VkBindImagePlaneMemoryInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect);
-}
-
-static inline void
-vn_encode_VkBindImagePlaneMemoryInfo(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO });
-    vn_encode_VkBindImagePlaneMemoryInfo_pnext(enc, val->pNext);
-    vn_encode_VkBindImagePlaneMemoryInfo_self(enc, val);
-}
-
-static inline void
-vn_decode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkImageAspectFlagBits(dec, &val->planeAspect);
-}
-
-static inline void
-vn_decode_VkBindImagePlaneMemoryInfo(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO);
-
-    assert(val->sType == stype);
-    vn_decode_VkBindImagePlaneMemoryInfo_pnext(dec, val->pNext);
-    vn_decode_VkBindImagePlaneMemoryInfo_self(dec, val);
-}
-
-/* struct VkBindImageMemoryInfo chain */
-
-static inline size_t
-vn_sizeof_VkBindImageMemoryInfo_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkBindImageMemoryInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self((const VkBindImageMemoryDeviceGroupInfo *)pnext);
-            return size;
-        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkBindImageMemoryInfo_pnext(pnext->pNext);
-            size += vn_sizeof_VkBindImagePlaneMemoryInfo_self((const VkBindImagePlaneMemoryInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBindImageMemoryInfo_self(const VkBindImageMemoryInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkImage(&val->image);
-    size += vn_sizeof_VkDeviceMemory(&val->memory);
-    size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBindImageMemoryInfo(const VkBindImageMemoryInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBindImageMemoryInfo_pnext(val->pNext);
-    size += vn_sizeof_VkBindImageMemoryInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBindImageMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, (const VkBindImageMemoryDeviceGroupInfo *)pnext);
-            return;
-        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext);
-            vn_encode_VkBindImagePlaneMemoryInfo_self(enc, (const VkBindImagePlaneMemoryInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBindImageMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkImage(enc, &val->image);
-    vn_encode_VkDeviceMemory(enc, &val->memory);
-    vn_encode_VkDeviceSize(enc, &val->memoryOffset);
-}
-
-static inline void
-vn_encode_VkBindImageMemoryInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO });
-    vn_encode_VkBindImageMemoryInfo_pnext(enc, val->pNext);
-    vn_encode_VkBindImageMemoryInfo_self(enc, val);
-}
-
-static inline void
-vn_decode_VkBindImageMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
-    VkStructureType stype;
-
-    if (!vn_decode_simple_pointer(dec))
-        return;
-
-    vn_decode_VkStructureType(dec, &stype);
-    while (true) {
-        assert(pnext);
-        if (pnext->sType == stype)
-            break;
-    }
-
-    switch ((int32_t)pnext->sType) {
-    case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
-        vn_decode_VkBindImageMemoryInfo_pnext(dec, pnext->pNext);
-        vn_decode_VkBindImageMemoryDeviceGroupInfo_self(dec, (VkBindImageMemoryDeviceGroupInfo *)pnext);
-        break;
-    case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
-        vn_decode_VkBindImageMemoryInfo_pnext(dec, pnext->pNext);
-        vn_decode_VkBindImagePlaneMemoryInfo_self(dec, (VkBindImagePlaneMemoryInfo *)pnext);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_decode_VkBindImageMemoryInfo_self(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkImage(dec, &val->image);
-    vn_decode_VkDeviceMemory(dec, &val->memory);
-    vn_decode_VkDeviceSize(dec, &val->memoryOffset);
-}
-
-static inline void
-vn_decode_VkBindImageMemoryInfo(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO);
-
-    assert(val->sType == stype);
-    vn_decode_VkBindImageMemoryInfo_pnext(dec, val->pNext);
-    vn_decode_VkBindImageMemoryInfo_self(dec, val);
-}
-
-/* struct VkDescriptorUpdateTemplateEntry */
-
-static inline size_t
-vn_sizeof_VkDescriptorUpdateTemplateEntry(const VkDescriptorUpdateTemplateEntry *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->dstBinding);
-    size += vn_sizeof_uint32_t(&val->dstArrayElement);
-    size += vn_sizeof_uint32_t(&val->descriptorCount);
-    size += vn_sizeof_VkDescriptorType(&val->descriptorType);
-    size += vn_sizeof_size_t(&val->offset);
-    size += vn_sizeof_size_t(&val->stride);
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorUpdateTemplateEntry(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateEntry *val)
-{
-    vn_encode_uint32_t(enc, &val->dstBinding);
-    vn_encode_uint32_t(enc, &val->dstArrayElement);
-    vn_encode_uint32_t(enc, &val->descriptorCount);
-    vn_encode_VkDescriptorType(enc, &val->descriptorType);
-    vn_encode_size_t(enc, &val->offset);
-    vn_encode_size_t(enc, &val->stride);
-}
-
-/* struct VkDescriptorUpdateTemplateCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_self(const VkDescriptorUpdateTemplateCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->descriptorUpdateEntryCount);
-    if (val->pDescriptorUpdateEntries) {
-        size += vn_sizeof_array_size(val->descriptorUpdateEntryCount);
-        for (uint32_t i = 0; i < val->descriptorUpdateEntryCount; i++)
-            size += vn_sizeof_VkDescriptorUpdateTemplateEntry(&val->pDescriptorUpdateEntries[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_VkDescriptorUpdateTemplateType(&val->templateType);
-    size += vn_sizeof_VkDescriptorSetLayout(&val->descriptorSetLayout);
-    size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);
-    size += vn_sizeof_VkPipelineLayout(&val->pipelineLayout);
-    size += vn_sizeof_uint32_t(&val->set);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorUpdateTemplateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDescriptorUpdateTemplateCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->descriptorUpdateEntryCount);
-    if (val->pDescriptorUpdateEntries) {
-        vn_encode_array_size(enc, val->descriptorUpdateEntryCount);
-        for (uint32_t i = 0; i < val->descriptorUpdateEntryCount; i++)
-            vn_encode_VkDescriptorUpdateTemplateEntry(enc, &val->pDescriptorUpdateEntries[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_VkDescriptorUpdateTemplateType(enc, &val->templateType);
-    vn_encode_VkDescriptorSetLayout(enc, &val->descriptorSetLayout);
-    vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);
-    vn_encode_VkPipelineLayout(enc, &val->pipelineLayout);
-    vn_encode_uint32_t(enc, &val->set);
-}
-
-static inline void
-vn_encode_VkDescriptorUpdateTemplateCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO });
-    vn_encode_VkDescriptorUpdateTemplateCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkDescriptorUpdateTemplateCreateInfo_self(enc, val);
-}
-
-/* struct VkBufferMemoryRequirementsInfo2 chain */
-
-static inline size_t
-vn_sizeof_VkBufferMemoryRequirementsInfo2_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkBufferMemoryRequirementsInfo2_self(const VkBufferMemoryRequirementsInfo2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBuffer(&val->buffer);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBufferMemoryRequirementsInfo2_pnext(val->pNext);
-    size += vn_sizeof_VkBufferMemoryRequirementsInfo2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkBufferMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkBufferMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkBufferMemoryRequirementsInfo2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkBuffer(enc, &val->buffer);
-}
-
-static inline void
-vn_encode_VkBufferMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkBufferMemoryRequirementsInfo2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 });
-    vn_encode_VkBufferMemoryRequirementsInfo2_pnext(enc, val->pNext);
-    vn_encode_VkBufferMemoryRequirementsInfo2_self(enc, val);
-}
-
-/* struct VkImagePlaneMemoryRequirementsInfo chain */
-
-static inline size_t
-vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(const VkImagePlaneMemoryRequirementsInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(val->pNext);
-    size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImagePlaneMemoryRequirementsInfo_self(struct vn_cs_encoder *enc, const VkImagePlaneMemoryRequirementsInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect);
-}
-
-static inline void
-vn_encode_VkImagePlaneMemoryRequirementsInfo(struct vn_cs_encoder *enc, const VkImagePlaneMemoryRequirementsInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO });
-    vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(enc, val->pNext);
-    vn_encode_VkImagePlaneMemoryRequirementsInfo_self(enc, val);
-}
-
-/* struct VkImageMemoryRequirementsInfo2 chain */
-
-static inline size_t
-vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(pnext->pNext);
-            size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self((const VkImagePlaneMemoryRequirementsInfo *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageMemoryRequirementsInfo2_self(const VkImageMemoryRequirementsInfo2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkImage(&val->image);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(val->pNext);
-    size += vn_sizeof_VkImageMemoryRequirementsInfo2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkImageMemoryRequirementsInfo2_pnext(enc, pnext->pNext);
-            vn_encode_VkImagePlaneMemoryRequirementsInfo_self(enc, (const VkImagePlaneMemoryRequirementsInfo *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkImageMemoryRequirementsInfo2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkImage(enc, &val->image);
-}
-
-static inline void
-vn_encode_VkImageMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkImageMemoryRequirementsInfo2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 });
-    vn_encode_VkImageMemoryRequirementsInfo2_pnext(enc, val->pNext);
-    vn_encode_VkImageMemoryRequirementsInfo2_self(enc, val);
-}
-
-/* struct VkImageSparseMemoryRequirementsInfo2 chain */
-
-static inline size_t
-vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(const VkImageSparseMemoryRequirementsInfo2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkImage(&val->image);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(val->pNext);
-    size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkImageSparseMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkImageSparseMemoryRequirementsInfo2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkImage(enc, &val->image);
-}
-
-static inline void
-vn_encode_VkImageSparseMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkImageSparseMemoryRequirementsInfo2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 });
-    vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(enc, val->pNext);
-    vn_encode_VkImageSparseMemoryRequirementsInfo2_self(enc, val);
-}
-
-/* struct VkMemoryDedicatedRequirements chain */
-
-static inline size_t
-vn_sizeof_VkMemoryDedicatedRequirements_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryDedicatedRequirements_self(const VkMemoryDedicatedRequirements *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->prefersDedicatedAllocation);
-    size += vn_sizeof_VkBool32(&val->requiresDedicatedAllocation);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkMemoryDedicatedRequirements_pnext(val->pNext);
-    size += vn_sizeof_VkMemoryDedicatedRequirements_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkMemoryDedicatedRequirements_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkMemoryDedicatedRequirements_self(struct vn_cs_decoder *dec, VkMemoryDedicatedRequirements *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->prefersDedicatedAllocation);
-    vn_decode_VkBool32(dec, &val->requiresDedicatedAllocation);
-}
-
-static inline void
-vn_decode_VkMemoryDedicatedRequirements(struct vn_cs_decoder *dec, VkMemoryDedicatedRequirements *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
-
-    assert(val->sType == stype);
-    vn_decode_VkMemoryDedicatedRequirements_pnext(dec, val->pNext);
-    vn_decode_VkMemoryDedicatedRequirements_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryDedicatedRequirements_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryDedicatedRequirements_self_partial(const VkMemoryDedicatedRequirements *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->prefersDedicatedAllocation */
-    /* skip val->requiresDedicatedAllocation */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkMemoryDedicatedRequirements_partial(const VkMemoryDedicatedRequirements *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkMemoryDedicatedRequirements_pnext_partial(val->pNext);
-    size += vn_sizeof_VkMemoryDedicatedRequirements_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkMemoryDedicatedRequirements_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkMemoryDedicatedRequirements_self_partial(struct vn_cs_encoder *enc, const VkMemoryDedicatedRequirements *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->prefersDedicatedAllocation */
-    /* skip val->requiresDedicatedAllocation */
-}
-
-static inline void
-vn_encode_VkMemoryDedicatedRequirements_partial(struct vn_cs_encoder *enc, const VkMemoryDedicatedRequirements *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS });
-    vn_encode_VkMemoryDedicatedRequirements_pnext_partial(enc, val->pNext);
-    vn_encode_VkMemoryDedicatedRequirements_self_partial(enc, val);
-}
-
-/* struct VkMemoryRequirements2 chain */
-
-static inline size_t
-vn_sizeof_VkMemoryRequirements2_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkMemoryRequirements2_pnext(pnext->pNext);
-            size += vn_sizeof_VkMemoryDedicatedRequirements_self((const VkMemoryDedicatedRequirements *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryRequirements2_self(const VkMemoryRequirements2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkMemoryRequirements(&val->memoryRequirements);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkMemoryRequirements2(const VkMemoryRequirements2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkMemoryRequirements2_pnext(val->pNext);
-    size += vn_sizeof_VkMemoryRequirements2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkMemoryRequirements2_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
-    VkStructureType stype;
-
-    if (!vn_decode_simple_pointer(dec))
-        return;
-
-    vn_decode_VkStructureType(dec, &stype);
-    while (true) {
-        assert(pnext);
-        if (pnext->sType == stype)
-            break;
-    }
-
-    switch ((int32_t)pnext->sType) {
-    case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
-        vn_decode_VkMemoryRequirements2_pnext(dec, pnext->pNext);
-        vn_decode_VkMemoryDedicatedRequirements_self(dec, (VkMemoryDedicatedRequirements *)pnext);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_decode_VkMemoryRequirements2_self(struct vn_cs_decoder *dec, VkMemoryRequirements2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkMemoryRequirements(dec, &val->memoryRequirements);
-}
-
-static inline void
-vn_decode_VkMemoryRequirements2(struct vn_cs_decoder *dec, VkMemoryRequirements2 *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2);
-
-    assert(val->sType == stype);
-    vn_decode_VkMemoryRequirements2_pnext(dec, val->pNext);
-    vn_decode_VkMemoryRequirements2_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryRequirements2_pnext_partial(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkMemoryRequirements2_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkMemoryDedicatedRequirements_self_partial((const VkMemoryDedicatedRequirements *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkMemoryRequirements2_self_partial(const VkMemoryRequirements2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkMemoryRequirements_partial(&val->memoryRequirements);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkMemoryRequirements2_partial(const VkMemoryRequirements2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkMemoryRequirements2_pnext_partial(val->pNext);
-    size += vn_sizeof_VkMemoryRequirements2_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkMemoryRequirements2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkMemoryRequirements2_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkMemoryDedicatedRequirements_self_partial(enc, (const VkMemoryDedicatedRequirements *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkMemoryRequirements2_self_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkMemoryRequirements_partial(enc, &val->memoryRequirements);
-}
-
-static inline void
-vn_encode_VkMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 });
-    vn_encode_VkMemoryRequirements2_pnext_partial(enc, val->pNext);
-    vn_encode_VkMemoryRequirements2_self_partial(enc, val);
-}
-
-/* struct VkSparseImageMemoryRequirements2 chain */
-
-static inline size_t
-vn_sizeof_VkSparseImageMemoryRequirements2_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageMemoryRequirements2_self(const VkSparseImageMemoryRequirements2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkSparseImageMemoryRequirements(&val->memoryRequirements);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSparseImageMemoryRequirements2_pnext(val->pNext);
-    size += vn_sizeof_VkSparseImageMemoryRequirements2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkSparseImageMemoryRequirements2_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkSparseImageMemoryRequirements2_self(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkSparseImageMemoryRequirements(dec, &val->memoryRequirements);
-}
-
-static inline void
-vn_decode_VkSparseImageMemoryRequirements2(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2);
-
-    assert(val->sType == stype);
-    vn_decode_VkSparseImageMemoryRequirements2_pnext(dec, val->pNext);
-    vn_decode_VkSparseImageMemoryRequirements2_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(const VkSparseImageMemoryRequirements2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&val->memoryRequirements);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSparseImageMemoryRequirements2_partial(const VkSparseImageMemoryRequirements2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(val->pNext);
-    size += vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSparseImageMemoryRequirements2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkSparseImageMemoryRequirements_partial(enc, &val->memoryRequirements);
-}
-
-static inline void
-vn_encode_VkSparseImageMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 });
-    vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(enc, val->pNext);
-    vn_encode_VkSparseImageMemoryRequirements2_self_partial(enc, val);
-}
-
-/* struct VkSamplerYcbcrConversionCreateInfo chain */
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionCreateInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionCreateInfo_self(const VkSamplerYcbcrConversionCreateInfo *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFormat(&val->format);
-    size += vn_sizeof_VkSamplerYcbcrModelConversion(&val->ycbcrModel);
-    size += vn_sizeof_VkSamplerYcbcrRange(&val->ycbcrRange);
-    size += vn_sizeof_VkComponentMapping(&val->components);
-    size += vn_sizeof_VkChromaLocation(&val->xChromaOffset);
-    size += vn_sizeof_VkChromaLocation(&val->yChromaOffset);
-    size += vn_sizeof_VkFilter(&val->chromaFilter);
-    size += vn_sizeof_VkBool32(&val->forceExplicitReconstruction);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSamplerYcbcrConversionCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSamplerYcbcrConversionCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionCreateInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFormat(enc, &val->format);
-    vn_encode_VkSamplerYcbcrModelConversion(enc, &val->ycbcrModel);
-    vn_encode_VkSamplerYcbcrRange(enc, &val->ycbcrRange);
-    vn_encode_VkComponentMapping(enc, &val->components);
-    vn_encode_VkChromaLocation(enc, &val->xChromaOffset);
-    vn_encode_VkChromaLocation(enc, &val->yChromaOffset);
-    vn_encode_VkFilter(enc, &val->chromaFilter);
-    vn_encode_VkBool32(enc, &val->forceExplicitReconstruction);
-}
-
-static inline void
-vn_encode_VkSamplerYcbcrConversionCreateInfo(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionCreateInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO });
-    vn_encode_VkSamplerYcbcrConversionCreateInfo_pnext(enc, val->pNext);
-    vn_encode_VkSamplerYcbcrConversionCreateInfo_self(enc, val);
-}
-
-/* struct VkDeviceQueueInfo2 chain */
-
-static inline size_t
-vn_sizeof_VkDeviceQueueInfo2_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
-    size += vn_sizeof_uint32_t(&val->queueIndex);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDeviceQueueInfo2_pnext(val->pNext);
-    size += vn_sizeof_VkDeviceQueueInfo2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->queueFamilyIndex);
-    vn_encode_uint32_t(enc, &val->queueIndex);
-}
-
-static inline void
-vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 });
-    vn_encode_VkDeviceQueueInfo2_pnext(enc, val->pNext);
-    vn_encode_VkDeviceQueueInfo2_self(enc, val);
-}
-
-/* struct VkDescriptorSetVariableDescriptorCountLayoutSupport chain */
-
-static inline size_t
-vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->maxVariableDescriptorCount);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(val->pNext);
-    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
-}
-
-static inline void
-vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(struct vn_cs_decoder *dec, VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_uint32_t(dec, &val->maxVariableDescriptorCount);
-}
-
-static inline void
-vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport(struct vn_cs_decoder *dec, VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
-
-    assert(val->sType == stype);
-    vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(dec, val->pNext);
-    vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->maxVariableDescriptorCount */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_partial(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(val->pNext);
-    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->maxVariableDescriptorCount */
-}
-
-static inline void
-vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_partial(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT });
-    vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(enc, val->pNext);
-    vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(enc, val);
-}
-
-/* struct VkDescriptorSetLayoutSupport chain */
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutSupport_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext(pnext->pNext);
-            size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self((const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutSupport_self(const VkDescriptorSetLayoutSupport *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBool32(&val->supported);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext(val->pNext);
-    size += vn_sizeof_VkDescriptorSetLayoutSupport_self(val);
-
-    return size;
-}
-
-static inline void
-vn_decode_VkDescriptorSetLayoutSupport_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
-    VkStructureType stype;
-
-    if (!vn_decode_simple_pointer(dec))
-        return;
-
-    vn_decode_VkStructureType(dec, &stype);
-    while (true) {
-        assert(pnext);
-        if (pnext->sType == stype)
-            break;
-    }
-
-    switch ((int32_t)pnext->sType) {
-    case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
-        vn_decode_VkDescriptorSetLayoutSupport_pnext(dec, pnext->pNext);
-        vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(dec, (VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-}
-
-static inline void
-vn_decode_VkDescriptorSetLayoutSupport_self(struct vn_cs_decoder *dec, VkDescriptorSetLayoutSupport *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBool32(dec, &val->supported);
-}
-
-static inline void
-vn_decode_VkDescriptorSetLayoutSupport(struct vn_cs_decoder *dec, VkDescriptorSetLayoutSupport *val)
-{
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT);
-
-    assert(val->sType == stype);
-    vn_decode_VkDescriptorSetLayoutSupport_pnext(dec, val->pNext);
-    vn_decode_VkDescriptorSetLayoutSupport_self(dec, val);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(pnext->pNext);
-            size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial((const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutSupport_self_partial(const VkDescriptorSetLayoutSupport *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    /* skip val->supported */
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkDescriptorSetLayoutSupport_partial(const VkDescriptorSetLayoutSupport *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(val->pNext);
-    size += vn_sizeof_VkDescriptorSetLayoutSupport_self_partial(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(enc, pnext->pNext);
-            vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(enc, (const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkDescriptorSetLayoutSupport_self_partial(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutSupport *val)
-{
-    /* skip val->{sType,pNext} */
-    /* skip val->supported */
-}
-
-static inline void
-vn_encode_VkDescriptorSetLayoutSupport_partial(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutSupport *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT });
-    vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(enc, val->pNext);
-    vn_encode_VkDescriptorSetLayoutSupport_self_partial(enc, val);
-}
-
-/* struct VkAttachmentDescriptionStencilLayout chain */
-
-static inline size_t
-vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkAttachmentDescriptionStencilLayout_self(const VkAttachmentDescriptionStencilLayout *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkImageLayout(&val->stencilInitialLayout);
-    size += vn_sizeof_VkImageLayout(&val->stencilFinalLayout);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(val->pNext);
-    size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkAttachmentDescriptionStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkAttachmentDescriptionStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkImageLayout(enc, &val->stencilInitialLayout);
-    vn_encode_VkImageLayout(enc, &val->stencilFinalLayout);
-}
-
-static inline void
-vn_encode_VkAttachmentDescriptionStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT });
-    vn_encode_VkAttachmentDescriptionStencilLayout_pnext(enc, val->pNext);
-    vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, val);
-}
-
-/* struct VkAttachmentDescription2 chain */
-
-static inline size_t
-vn_sizeof_VkAttachmentDescription2_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkAttachmentDescription2_pnext(pnext->pNext);
-            size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self((const VkAttachmentDescriptionStencilLayout *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkAttachmentDescription2_self(const VkAttachmentDescription2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkFormat(&val->format);
-    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
-    size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp);
-    size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp);
-    size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp);
-    size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp);
-    size += vn_sizeof_VkImageLayout(&val->initialLayout);
-    size += vn_sizeof_VkImageLayout(&val->finalLayout);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkAttachmentDescription2(const VkAttachmentDescription2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkAttachmentDescription2_pnext(val->pNext);
-    size += vn_sizeof_VkAttachmentDescription2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkAttachmentDescription2_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkAttachmentDescription2_pnext(enc, pnext->pNext);
-            vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, (const VkAttachmentDescriptionStencilLayout *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkAttachmentDescription2_self(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkFormat(enc, &val->format);
-    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
-    vn_encode_VkAttachmentLoadOp(enc, &val->loadOp);
-    vn_encode_VkAttachmentStoreOp(enc, &val->storeOp);
-    vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp);
-    vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp);
-    vn_encode_VkImageLayout(enc, &val->initialLayout);
-    vn_encode_VkImageLayout(enc, &val->finalLayout);
-}
-
-static inline void
-vn_encode_VkAttachmentDescription2(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 });
-    vn_encode_VkAttachmentDescription2_pnext(enc, val->pNext);
-    vn_encode_VkAttachmentDescription2_self(enc, val);
-}
-
-/* struct VkAttachmentReferenceStencilLayout chain */
-
-static inline size_t
-vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkAttachmentReferenceStencilLayout_self(const VkAttachmentReferenceStencilLayout *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkImageLayout(&val->stencilLayout);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(val->pNext);
-    size += vn_sizeof_VkAttachmentReferenceStencilLayout_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkAttachmentReferenceStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkAttachmentReferenceStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkImageLayout(enc, &val->stencilLayout);
-}
-
-static inline void
-vn_encode_VkAttachmentReferenceStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT });
-    vn_encode_VkAttachmentReferenceStencilLayout_pnext(enc, val->pNext);
-    vn_encode_VkAttachmentReferenceStencilLayout_self(enc, val);
-}
-
-/* struct VkAttachmentReference2 chain */
-
-static inline size_t
-vn_sizeof_VkAttachmentReference2_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkAttachmentReference2_pnext(pnext->pNext);
-            size += vn_sizeof_VkAttachmentReferenceStencilLayout_self((const VkAttachmentReferenceStencilLayout *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkAttachmentReference2_self(const VkAttachmentReference2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->attachment);
-    size += vn_sizeof_VkImageLayout(&val->layout);
     size += vn_sizeof_VkFlags(&val->aspectMask);
+    size += vn_sizeof_uint32_t(&val->mipLevel);
+    size += vn_sizeof_uint32_t(&val->arrayLayer);
     return size;
 }
 
-static inline size_t
-vn_sizeof_VkAttachmentReference2(const VkAttachmentReference2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkAttachmentReference2_pnext(val->pNext);
-    size += vn_sizeof_VkAttachmentReference2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkAttachmentReference2_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkAttachmentReference2_pnext(enc, pnext->pNext);
-            vn_encode_VkAttachmentReferenceStencilLayout_self(enc, (const VkAttachmentReferenceStencilLayout *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
 static inline void
-vn_encode_VkAttachmentReference2_self(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val)
+vn_encode_VkImageSubresource(struct vn_cs_encoder *enc, const VkImageSubresource *val)
 {
-    /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->attachment);
-    vn_encode_VkImageLayout(enc, &val->layout);
     vn_encode_VkFlags(enc, &val->aspectMask);
+    vn_encode_uint32_t(enc, &val->mipLevel);
+    vn_encode_uint32_t(enc, &val->arrayLayer);
 }
 
-static inline void
-vn_encode_VkAttachmentReference2(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 });
-    vn_encode_VkAttachmentReference2_pnext(enc, val->pNext);
-    vn_encode_VkAttachmentReference2_self(enc, val);
-}
-
-/* struct VkSubpassDescriptionDepthStencilResolve chain */
-
-static inline size_t
-vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(const void *val)
-{
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(const VkSubpassDescriptionDepthStencilResolve *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkResolveModeFlagBits(&val->depthResolveMode);
-    size += vn_sizeof_VkResolveModeFlagBits(&val->stencilResolveMode);
-    size += vn_sizeof_simple_pointer(val->pDepthStencilResolveAttachment);
-    if (val->pDepthStencilResolveAttachment)
-        size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilResolveAttachment);
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(val->pNext);
-    size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSubpassDescriptionDepthStencilResolve_self(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkResolveModeFlagBits(enc, &val->depthResolveMode);
-    vn_encode_VkResolveModeFlagBits(enc, &val->stencilResolveMode);
-    if (vn_encode_simple_pointer(enc, val->pDepthStencilResolveAttachment))
-        vn_encode_VkAttachmentReference2(enc, val->pDepthStencilResolveAttachment);
-}
-
-static inline void
-vn_encode_VkSubpassDescriptionDepthStencilResolve(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE });
-    vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(enc, val->pNext);
-    vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, val);
-}
-
-/* struct VkSubpassDescription2 chain */
-
-static inline size_t
-vn_sizeof_VkSubpassDescription2_pnext(const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-    size_t size = 0;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
-            size += vn_sizeof_simple_pointer(pnext);
-            size += vn_sizeof_VkStructureType(&pnext->sType);
-            size += vn_sizeof_VkSubpassDescription2_pnext(pnext->pNext);
-            size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self((const VkSubpassDescriptionDepthStencilResolve *)pnext);
-            return size;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    return vn_sizeof_simple_pointer(NULL);
-}
-
-static inline size_t
-vn_sizeof_VkSubpassDescription2_self(const VkSubpassDescription2 *val)
-{
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);
-    size += vn_sizeof_uint32_t(&val->viewMask);
-    size += vn_sizeof_uint32_t(&val->inputAttachmentCount);
-    if (val->pInputAttachments) {
-        size += vn_sizeof_array_size(val->inputAttachmentCount);
-        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
-            size += vn_sizeof_VkAttachmentReference2(&val->pInputAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
-    if (val->pColorAttachments) {
-        size += vn_sizeof_array_size(val->colorAttachmentCount);
-        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
-            size += vn_sizeof_VkAttachmentReference2(&val->pColorAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    if (val->pResolveAttachments) {
-        size += vn_sizeof_array_size(val->colorAttachmentCount);
-        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
-            size += vn_sizeof_VkAttachmentReference2(&val->pResolveAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment);
-    if (val->pDepthStencilAttachment)
-        size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilAttachment);
-    size += vn_sizeof_uint32_t(&val->preserveAttachmentCount);
-    if (val->pPreserveAttachments) {
-        size += vn_sizeof_array_size(val->preserveAttachmentCount);
-        size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    return size;
-}
-
-static inline size_t
-vn_sizeof_VkSubpassDescription2(const VkSubpassDescription2 *val)
-{
-    size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSubpassDescription2_pnext(val->pNext);
-    size += vn_sizeof_VkSubpassDescription2_self(val);
-
-    return size;
-}
-
-static inline void
-vn_encode_VkSubpassDescription2_pnext(struct vn_cs_encoder *enc, const void *val)
-{
-    const VkBaseInStructure *pnext = val;
-
-    while (pnext) {
-        switch ((int32_t)pnext->sType) {
-        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
-            vn_encode_simple_pointer(enc, pnext);
-            vn_encode_VkStructureType(enc, &pnext->sType);
-            vn_encode_VkSubpassDescription2_pnext(enc, pnext->pNext);
-            vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, (const VkSubpassDescriptionDepthStencilResolve *)pnext);
-            return;
-        default:
-            /* ignore unknown/unsupported struct */
-            break;
-        }
-        pnext = pnext->pNext;
-    }
-
-    vn_encode_simple_pointer(enc, NULL);
-}
-
-static inline void
-vn_encode_VkSubpassDescription2_self(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val)
+/* struct VkOffset3D */
+
+static inline size_t
+vn_sizeof_VkOffset3D(const VkOffset3D *val)
 {
-    /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);
-    vn_encode_uint32_t(enc, &val->viewMask);
-    vn_encode_uint32_t(enc, &val->inputAttachmentCount);
-    if (val->pInputAttachments) {
-        vn_encode_array_size(enc, val->inputAttachmentCount);
-        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
-            vn_encode_VkAttachmentReference2(enc, &val->pInputAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->colorAttachmentCount);
-    if (val->pColorAttachments) {
-        vn_encode_array_size(enc, val->colorAttachmentCount);
-        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
-            vn_encode_VkAttachmentReference2(enc, &val->pColorAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (val->pResolveAttachments) {
-        vn_encode_array_size(enc, val->colorAttachmentCount);
-        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
-            vn_encode_VkAttachmentReference2(enc, &val->pResolveAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment))
-        vn_encode_VkAttachmentReference2(enc, val->pDepthStencilAttachment);
-    vn_encode_uint32_t(enc, &val->preserveAttachmentCount);
-    if (val->pPreserveAttachments) {
-        vn_encode_array_size(enc, val->preserveAttachmentCount);
-        vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
+    size_t size = 0;
+    size += vn_sizeof_int32_t(&val->x);
+    size += vn_sizeof_int32_t(&val->y);
+    size += vn_sizeof_int32_t(&val->z);
+    return size;
 }
 
 static inline void
-vn_encode_VkSubpassDescription2(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val)
+vn_encode_VkOffset3D(struct vn_cs_encoder *enc, const VkOffset3D *val)
 {
-    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 });
-    vn_encode_VkSubpassDescription2_pnext(enc, val->pNext);
-    vn_encode_VkSubpassDescription2_self(enc, val);
+    vn_encode_int32_t(enc, &val->x);
+    vn_encode_int32_t(enc, &val->y);
+    vn_encode_int32_t(enc, &val->z);
 }
 
-/* struct VkSubpassDependency2 chain */
+/* struct VkSemaphoreTypeCreateInfo chain */
 
 static inline size_t
-vn_sizeof_VkSubpassDependency2_pnext(const void *val)
+vn_sizeof_VkSemaphoreTypeCreateInfo_pnext(const void *val)
 {
     /* no known/supported struct */
     return vn_sizeof_simple_pointer(NULL);
 }
 
 static inline size_t
-vn_sizeof_VkSubpassDependency2_self(const VkSubpassDependency2 *val)
+vn_sizeof_VkSemaphoreTypeCreateInfo_self(const VkSemaphoreTypeCreateInfo *val)
 {
     size_t size = 0;
     /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint32_t(&val->srcSubpass);
-    size += vn_sizeof_uint32_t(&val->dstSubpass);
-    size += vn_sizeof_VkFlags(&val->srcStageMask);
-    size += vn_sizeof_VkFlags(&val->dstStageMask);
-    size += vn_sizeof_VkFlags(&val->srcAccessMask);
-    size += vn_sizeof_VkFlags(&val->dstAccessMask);
-    size += vn_sizeof_VkFlags(&val->dependencyFlags);
-    size += vn_sizeof_int32_t(&val->viewOffset);
+    size += vn_sizeof_VkSemaphoreType(&val->semaphoreType);
+    size += vn_sizeof_uint64_t(&val->initialValue);
     return size;
 }
 
 static inline size_t
-vn_sizeof_VkSubpassDependency2(const VkSubpassDependency2 *val)
+vn_sizeof_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo *val)
 {
     size_t size = 0;
 
     size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSubpassDependency2_pnext(val->pNext);
-    size += vn_sizeof_VkSubpassDependency2_self(val);
+    size += vn_sizeof_VkSemaphoreTypeCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSemaphoreTypeCreateInfo_self(val);
 
     return size;
 }
 
 static inline void
-vn_encode_VkSubpassDependency2_pnext(struct vn_cs_encoder *enc, const void *val)
+vn_encode_VkSemaphoreTypeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
 {
     /* no known/supported struct */
     vn_encode_simple_pointer(enc, NULL);
 }
 
 static inline void
-vn_encode_VkSubpassDependency2_self(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val)
+vn_encode_VkSemaphoreTypeCreateInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreTypeCreateInfo *val)
 {
     /* skip val->{sType,pNext} */
-    vn_encode_uint32_t(enc, &val->srcSubpass);
-    vn_encode_uint32_t(enc, &val->dstSubpass);
-    vn_encode_VkFlags(enc, &val->srcStageMask);
-    vn_encode_VkFlags(enc, &val->dstStageMask);
-    vn_encode_VkFlags(enc, &val->srcAccessMask);
-    vn_encode_VkFlags(enc, &val->dstAccessMask);
-    vn_encode_VkFlags(enc, &val->dependencyFlags);
-    vn_encode_int32_t(enc, &val->viewOffset);
+    vn_encode_VkSemaphoreType(enc, &val->semaphoreType);
+    vn_encode_uint64_t(enc, &val->initialValue);
 }
 
 static inline void
-vn_encode_VkSubpassDependency2(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val)
+vn_encode_VkSemaphoreTypeCreateInfo(struct vn_cs_encoder *enc, const VkSemaphoreTypeCreateInfo *val)
 {
-    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 });
-    vn_encode_VkSubpassDependency2_pnext(enc, val->pNext);
-    vn_encode_VkSubpassDependency2_self(enc, val);
+    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO });
+    vn_encode_VkSemaphoreTypeCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkSemaphoreTypeCreateInfo_self(enc, val);
 }
 
-/* struct VkRenderPassCreateInfo2 chain */
+/* struct VkImageFormatListCreateInfo chain */
 
 static inline size_t
-vn_sizeof_VkRenderPassCreateInfo2_pnext(const void *val)
+vn_sizeof_VkImageFormatListCreateInfo_pnext(const void *val)
 {
     /* no known/supported struct */
     return vn_sizeof_simple_pointer(NULL);
 }
 
 static inline size_t
-vn_sizeof_VkRenderPassCreateInfo2_self(const VkRenderPassCreateInfo2 *val)
+vn_sizeof_VkImageFormatListCreateInfo_self(const VkImageFormatListCreateInfo *val)
 {
     size_t size = 0;
     /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->attachmentCount);
-    if (val->pAttachments) {
-        size += vn_sizeof_array_size(val->attachmentCount);
-        for (uint32_t i = 0; i < val->attachmentCount; i++)
-            size += vn_sizeof_VkAttachmentDescription2(&val->pAttachments[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->subpassCount);
-    if (val->pSubpasses) {
-        size += vn_sizeof_array_size(val->subpassCount);
-        for (uint32_t i = 0; i < val->subpassCount; i++)
-            size += vn_sizeof_VkSubpassDescription2(&val->pSubpasses[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->dependencyCount);
-    if (val->pDependencies) {
-        size += vn_sizeof_array_size(val->dependencyCount);
-        for (uint32_t i = 0; i < val->dependencyCount; i++)
-            size += vn_sizeof_VkSubpassDependency2(&val->pDependencies[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    size += vn_sizeof_uint32_t(&val->correlatedViewMaskCount);
-    if (val->pCorrelatedViewMasks) {
-        size += vn_sizeof_array_size(val->correlatedViewMaskCount);
-        size += vn_sizeof_uint32_t_array(val->pCorrelatedViewMasks, val->correlatedViewMaskCount);
+    size += vn_sizeof_uint32_t(&val->viewFormatCount);
+    if (val->pViewFormats) {
+        size += vn_sizeof_array_size(val->viewFormatCount);
+        size += vn_sizeof_VkFormat_array(val->pViewFormats, val->viewFormatCount);
     } else {
         size += vn_sizeof_array_size(0);
     }
@@ -20745,722 +346,663 @@ vn_sizeof_VkRenderPassCreateInfo2_self(const VkRenderPassCreateInfo2 *val)
 }
 
 static inline size_t
-vn_sizeof_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 *val)
+vn_sizeof_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo *val)
 {
     size_t size = 0;
 
     size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkRenderPassCreateInfo2_pnext(val->pNext);
-    size += vn_sizeof_VkRenderPassCreateInfo2_self(val);
+    size += vn_sizeof_VkImageFormatListCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkImageFormatListCreateInfo_self(val);
 
     return size;
 }
 
 static inline void
-vn_encode_VkRenderPassCreateInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
+vn_encode_VkImageFormatListCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
 {
     /* no known/supported struct */
     vn_encode_simple_pointer(enc, NULL);
 }
 
 static inline void
-vn_encode_VkRenderPassCreateInfo2_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val)
+vn_encode_VkImageFormatListCreateInfo_self(struct vn_cs_encoder *enc, const VkImageFormatListCreateInfo *val)
 {
     /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->attachmentCount);
-    if (val->pAttachments) {
-        vn_encode_array_size(enc, val->attachmentCount);
-        for (uint32_t i = 0; i < val->attachmentCount; i++)
-            vn_encode_VkAttachmentDescription2(enc, &val->pAttachments[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->subpassCount);
-    if (val->pSubpasses) {
-        vn_encode_array_size(enc, val->subpassCount);
-        for (uint32_t i = 0; i < val->subpassCount; i++)
-            vn_encode_VkSubpassDescription2(enc, &val->pSubpasses[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->dependencyCount);
-    if (val->pDependencies) {
-        vn_encode_array_size(enc, val->dependencyCount);
-        for (uint32_t i = 0; i < val->dependencyCount; i++)
-            vn_encode_VkSubpassDependency2(enc, &val->pDependencies[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    vn_encode_uint32_t(enc, &val->correlatedViewMaskCount);
-    if (val->pCorrelatedViewMasks) {
-        vn_encode_array_size(enc, val->correlatedViewMaskCount);
-        vn_encode_uint32_t_array(enc, val->pCorrelatedViewMasks, val->correlatedViewMaskCount);
+    vn_encode_uint32_t(enc, &val->viewFormatCount);
+    if (val->pViewFormats) {
+        vn_encode_array_size(enc, val->viewFormatCount);
+        vn_encode_VkFormat_array(enc, val->pViewFormats, val->viewFormatCount);
     } else {
         vn_encode_array_size(enc, 0);
     }
 }
 
 static inline void
-vn_encode_VkRenderPassCreateInfo2(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val)
+vn_encode_VkImageFormatListCreateInfo(struct vn_cs_encoder *enc, const VkImageFormatListCreateInfo *val)
 {
-    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 });
-    vn_encode_VkRenderPassCreateInfo2_pnext(enc, val->pNext);
-    vn_encode_VkRenderPassCreateInfo2_self(enc, val);
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO });
+    vn_encode_VkImageFormatListCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkImageFormatListCreateInfo_self(enc, val);
 }
 
-/* struct VkSubpassBeginInfo chain */
+/* struct VkImageStencilUsageCreateInfo chain */
 
 static inline size_t
-vn_sizeof_VkSubpassBeginInfo_pnext(const void *val)
+vn_sizeof_VkImageStencilUsageCreateInfo_pnext(const void *val)
 {
     /* no known/supported struct */
     return vn_sizeof_simple_pointer(NULL);
 }
 
 static inline size_t
-vn_sizeof_VkSubpassBeginInfo_self(const VkSubpassBeginInfo *val)
+vn_sizeof_VkImageStencilUsageCreateInfo_self(const VkImageStencilUsageCreateInfo *val)
 {
     size_t size = 0;
     /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkSubpassContents(&val->contents);
+    size += vn_sizeof_VkFlags(&val->stencilUsage);
     return size;
 }
 
 static inline size_t
-vn_sizeof_VkSubpassBeginInfo(const VkSubpassBeginInfo *val)
+vn_sizeof_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo *val)
 {
     size_t size = 0;
 
     size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSubpassBeginInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSubpassBeginInfo_self(val);
+    size += vn_sizeof_VkImageStencilUsageCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkImageStencilUsageCreateInfo_self(val);
 
     return size;
 }
 
 static inline void
-vn_encode_VkSubpassBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+vn_encode_VkImageStencilUsageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
 {
     /* no known/supported struct */
     vn_encode_simple_pointer(enc, NULL);
 }
 
 static inline void
-vn_encode_VkSubpassBeginInfo_self(struct vn_cs_encoder *enc, const VkSubpassBeginInfo *val)
+vn_encode_VkImageStencilUsageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageStencilUsageCreateInfo *val)
 {
     /* skip val->{sType,pNext} */
-    vn_encode_VkSubpassContents(enc, &val->contents);
+    vn_encode_VkFlags(enc, &val->stencilUsage);
 }
 
 static inline void
-vn_encode_VkSubpassBeginInfo(struct vn_cs_encoder *enc, const VkSubpassBeginInfo *val)
+vn_encode_VkImageStencilUsageCreateInfo(struct vn_cs_encoder *enc, const VkImageStencilUsageCreateInfo *val)
 {
-    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO });
-    vn_encode_VkSubpassBeginInfo_pnext(enc, val->pNext);
-    vn_encode_VkSubpassBeginInfo_self(enc, val);
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO });
+    vn_encode_VkImageStencilUsageCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkImageStencilUsageCreateInfo_self(enc, val);
 }
 
-/* struct VkSubpassEndInfo chain */
+/* struct VkComponentMapping */
 
 static inline size_t
-vn_sizeof_VkSubpassEndInfo_pnext(const void *val)
+vn_sizeof_VkComponentMapping(const VkComponentMapping *val)
 {
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
+    size_t size = 0;
+    size += vn_sizeof_VkComponentSwizzle(&val->r);
+    size += vn_sizeof_VkComponentSwizzle(&val->g);
+    size += vn_sizeof_VkComponentSwizzle(&val->b);
+    size += vn_sizeof_VkComponentSwizzle(&val->a);
+    return size;
 }
 
-static inline size_t
-vn_sizeof_VkSubpassEndInfo_self(const VkSubpassEndInfo *val)
+static inline void
+vn_encode_VkComponentMapping(struct vn_cs_encoder *enc, const VkComponentMapping *val)
 {
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    return size;
+    vn_encode_VkComponentSwizzle(enc, &val->r);
+    vn_encode_VkComponentSwizzle(enc, &val->g);
+    vn_encode_VkComponentSwizzle(enc, &val->b);
+    vn_encode_VkComponentSwizzle(enc, &val->a);
+}
+
+static inline void
+vn_decode_VkComponentMapping(struct vn_cs_decoder *dec, VkComponentMapping *val)
+{
+    vn_decode_VkComponentSwizzle(dec, &val->r);
+    vn_decode_VkComponentSwizzle(dec, &val->g);
+    vn_decode_VkComponentSwizzle(dec, &val->b);
+    vn_decode_VkComponentSwizzle(dec, &val->a);
 }
 
 static inline size_t
-vn_sizeof_VkSubpassEndInfo(const VkSubpassEndInfo *val)
+vn_sizeof_VkComponentMapping_partial(const VkComponentMapping *val)
 {
     size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSubpassEndInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSubpassEndInfo_self(val);
-
+    /* skip val->r */
+    /* skip val->g */
+    /* skip val->b */
+    /* skip val->a */
     return size;
 }
 
 static inline void
-vn_encode_VkSubpassEndInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+vn_encode_VkComponentMapping_partial(struct vn_cs_encoder *enc, const VkComponentMapping *val)
 {
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
+    /* skip val->r */
+    /* skip val->g */
+    /* skip val->b */
+    /* skip val->a */
 }
 
-static inline void
-vn_encode_VkSubpassEndInfo_self(struct vn_cs_encoder *enc, const VkSubpassEndInfo *val)
+/* struct VkImageSubresourceRange */
+
+static inline size_t
+vn_sizeof_VkImageSubresourceRange(const VkImageSubresourceRange *val)
 {
-    /* skip val->{sType,pNext} */
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->aspectMask);
+    size += vn_sizeof_uint32_t(&val->baseMipLevel);
+    size += vn_sizeof_uint32_t(&val->levelCount);
+    size += vn_sizeof_uint32_t(&val->baseArrayLayer);
+    size += vn_sizeof_uint32_t(&val->layerCount);
+    return size;
 }
 
 static inline void
-vn_encode_VkSubpassEndInfo(struct vn_cs_encoder *enc, const VkSubpassEndInfo *val)
+vn_encode_VkImageSubresourceRange(struct vn_cs_encoder *enc, const VkImageSubresourceRange *val)
 {
-    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_END_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_END_INFO });
-    vn_encode_VkSubpassEndInfo_pnext(enc, val->pNext);
-    vn_encode_VkSubpassEndInfo_self(enc, val);
+    vn_encode_VkFlags(enc, &val->aspectMask);
+    vn_encode_uint32_t(enc, &val->baseMipLevel);
+    vn_encode_uint32_t(enc, &val->levelCount);
+    vn_encode_uint32_t(enc, &val->baseArrayLayer);
+    vn_encode_uint32_t(enc, &val->layerCount);
 }
 
-/* struct VkSemaphoreWaitInfo chain */
+/* struct VkSamplerYcbcrConversionInfo chain */
 
 static inline size_t
-vn_sizeof_VkSemaphoreWaitInfo_pnext(const void *val)
+vn_sizeof_VkSamplerYcbcrConversionInfo_pnext(const void *val)
 {
     /* no known/supported struct */
     return vn_sizeof_simple_pointer(NULL);
 }
 
 static inline size_t
-vn_sizeof_VkSemaphoreWaitInfo_self(const VkSemaphoreWaitInfo *val)
+vn_sizeof_VkSamplerYcbcrConversionInfo_self(const VkSamplerYcbcrConversionInfo *val)
 {
     size_t size = 0;
     /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->semaphoreCount);
-    if (val->pSemaphores) {
-        size += vn_sizeof_array_size(val->semaphoreCount);
-        for (uint32_t i = 0; i < val->semaphoreCount; i++)
-            size += vn_sizeof_VkSemaphore(&val->pSemaphores[i]);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
-    if (val->pValues) {
-        size += vn_sizeof_array_size(val->semaphoreCount);
-        size += vn_sizeof_uint64_t_array(val->pValues, val->semaphoreCount);
-    } else {
-        size += vn_sizeof_array_size(0);
-    }
+    size += vn_sizeof_VkSamplerYcbcrConversion(&val->conversion);
     return size;
 }
 
 static inline size_t
-vn_sizeof_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo *val)
+vn_sizeof_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo *val)
 {
     size_t size = 0;
 
     size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSemaphoreWaitInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSemaphoreWaitInfo_self(val);
+    size += vn_sizeof_VkSamplerYcbcrConversionInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSamplerYcbcrConversionInfo_self(val);
 
     return size;
 }
 
 static inline void
-vn_encode_VkSemaphoreWaitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+vn_encode_VkSamplerYcbcrConversionInfo_pnext(struct vn_cs_encoder *enc, const void *val)
 {
     /* no known/supported struct */
     vn_encode_simple_pointer(enc, NULL);
 }
 
 static inline void
-vn_encode_VkSemaphoreWaitInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreWaitInfo *val)
+vn_encode_VkSamplerYcbcrConversionInfo_self(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionInfo *val)
 {
     /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->semaphoreCount);
-    if (val->pSemaphores) {
-        vn_encode_array_size(enc, val->semaphoreCount);
-        for (uint32_t i = 0; i < val->semaphoreCount; i++)
-            vn_encode_VkSemaphore(enc, &val->pSemaphores[i]);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
-    if (val->pValues) {
-        vn_encode_array_size(enc, val->semaphoreCount);
-        vn_encode_uint64_t_array(enc, val->pValues, val->semaphoreCount);
-    } else {
-        vn_encode_array_size(enc, 0);
-    }
+    vn_encode_VkSamplerYcbcrConversion(enc, &val->conversion);
 }
 
 static inline void
-vn_encode_VkSemaphoreWaitInfo(struct vn_cs_encoder *enc, const VkSemaphoreWaitInfo *val)
+vn_encode_VkSamplerYcbcrConversionInfo(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionInfo *val)
 {
-    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO });
-    vn_encode_VkSemaphoreWaitInfo_pnext(enc, val->pNext);
-    vn_encode_VkSemaphoreWaitInfo_self(enc, val);
+    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO });
+    vn_encode_VkSamplerYcbcrConversionInfo_pnext(enc, val->pNext);
+    vn_encode_VkSamplerYcbcrConversionInfo_self(enc, val);
 }
 
-/* struct VkSemaphoreSignalInfo chain */
+/* struct VkViewport */
 
 static inline size_t
-vn_sizeof_VkSemaphoreSignalInfo_pnext(const void *val)
+vn_sizeof_VkViewport(const VkViewport *val)
 {
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
+    size_t size = 0;
+    size += vn_sizeof_float(&val->x);
+    size += vn_sizeof_float(&val->y);
+    size += vn_sizeof_float(&val->width);
+    size += vn_sizeof_float(&val->height);
+    size += vn_sizeof_float(&val->minDepth);
+    size += vn_sizeof_float(&val->maxDepth);
+    return size;
 }
 
-static inline size_t
-vn_sizeof_VkSemaphoreSignalInfo_self(const VkSemaphoreSignalInfo *val)
+static inline void
+vn_encode_VkViewport(struct vn_cs_encoder *enc, const VkViewport *val)
 {
-    size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkSemaphore(&val->semaphore);
-    size += vn_sizeof_uint64_t(&val->value);
-    return size;
+    vn_encode_float(enc, &val->x);
+    vn_encode_float(enc, &val->y);
+    vn_encode_float(enc, &val->width);
+    vn_encode_float(enc, &val->height);
+    vn_encode_float(enc, &val->minDepth);
+    vn_encode_float(enc, &val->maxDepth);
 }
 
+/* struct VkOffset2D */
+
 static inline size_t
-vn_sizeof_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo *val)
+vn_sizeof_VkOffset2D(const VkOffset2D *val)
 {
     size_t size = 0;
-
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkSemaphoreSignalInfo_pnext(val->pNext);
-    size += vn_sizeof_VkSemaphoreSignalInfo_self(val);
-
+    size += vn_sizeof_int32_t(&val->x);
+    size += vn_sizeof_int32_t(&val->y);
     return size;
 }
 
 static inline void
-vn_encode_VkSemaphoreSignalInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+vn_encode_VkOffset2D(struct vn_cs_encoder *enc, const VkOffset2D *val)
 {
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
+    vn_encode_int32_t(enc, &val->x);
+    vn_encode_int32_t(enc, &val->y);
 }
 
 static inline void
-vn_encode_VkSemaphoreSignalInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreSignalInfo *val)
+vn_decode_VkOffset2D(struct vn_cs_decoder *dec, VkOffset2D *val)
 {
-    /* skip val->{sType,pNext} */
-    vn_encode_VkSemaphore(enc, &val->semaphore);
-    vn_encode_uint64_t(enc, &val->value);
+    vn_decode_int32_t(dec, &val->x);
+    vn_decode_int32_t(dec, &val->y);
 }
 
-static inline void
-vn_encode_VkSemaphoreSignalInfo(struct vn_cs_encoder *enc, const VkSemaphoreSignalInfo *val)
+static inline size_t
+vn_sizeof_VkOffset2D_partial(const VkOffset2D *val)
 {
-    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO });
-    vn_encode_VkSemaphoreSignalInfo_pnext(enc, val->pNext);
-    vn_encode_VkSemaphoreSignalInfo_self(enc, val);
+    size_t size = 0;
+    /* skip val->x */
+    /* skip val->y */
+    return size;
 }
 
 static inline void
-vn_decode_VkSemaphoreSignalInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+vn_encode_VkOffset2D_partial(struct vn_cs_encoder *enc, const VkOffset2D *val)
 {
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
+    /* skip val->x */
+    /* skip val->y */
 }
 
-static inline void
-vn_decode_VkSemaphoreSignalInfo_self(struct vn_cs_decoder *dec, VkSemaphoreSignalInfo *val)
+/* struct VkExtent2D */
+
+static inline size_t
+vn_sizeof_VkExtent2D(const VkExtent2D *val)
 {
-    /* skip val->{sType,pNext} */
-    vn_decode_VkSemaphore(dec, &val->semaphore);
-    vn_decode_uint64_t(dec, &val->value);
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->width);
+    size += vn_sizeof_uint32_t(&val->height);
+    return size;
 }
 
 static inline void
-vn_decode_VkSemaphoreSignalInfo(struct vn_cs_decoder *dec, VkSemaphoreSignalInfo *val)
+vn_encode_VkExtent2D(struct vn_cs_encoder *enc, const VkExtent2D *val)
 {
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO);
-
-    assert(val->sType == stype);
-    vn_decode_VkSemaphoreSignalInfo_pnext(dec, val->pNext);
-    vn_decode_VkSemaphoreSignalInfo_self(dec, val);
+    vn_encode_uint32_t(enc, &val->width);
+    vn_encode_uint32_t(enc, &val->height);
 }
 
-/* struct VkImageDrmFormatModifierPropertiesEXT chain */
-
-static inline size_t
-vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(const void *val)
+static inline void
+vn_decode_VkExtent2D(struct vn_cs_decoder *dec, VkExtent2D *val)
 {
-    /* no known/supported struct */
-    return vn_sizeof_simple_pointer(NULL);
+    vn_decode_uint32_t(dec, &val->width);
+    vn_decode_uint32_t(dec, &val->height);
 }
 
 static inline size_t
-vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(const VkImageDrmFormatModifierPropertiesEXT *val)
+vn_sizeof_VkExtent2D_partial(const VkExtent2D *val)
 {
     size_t size = 0;
-    /* skip val->{sType,pNext} */
-    size += vn_sizeof_uint64_t(&val->drmFormatModifier);
+    /* skip val->width */
+    /* skip val->height */
     return size;
 }
 
-static inline size_t
-vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT *val)
+static inline void
+vn_encode_VkExtent2D_partial(struct vn_cs_encoder *enc, const VkExtent2D *val)
 {
-    size_t size = 0;
+    /* skip val->width */
+    /* skip val->height */
+}
 
-    size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(val->pNext);
-    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(val);
+/* struct VkRect2D */
 
+static inline size_t
+vn_sizeof_VkRect2D(const VkRect2D *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkOffset2D(&val->offset);
+    size += vn_sizeof_VkExtent2D(&val->extent);
     return size;
 }
 
 static inline void
-vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
+vn_encode_VkRect2D(struct vn_cs_encoder *enc, const VkRect2D *val)
 {
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
+    vn_encode_VkOffset2D(enc, &val->offset);
+    vn_encode_VkExtent2D(enc, &val->extent);
 }
 
 static inline void
-vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val)
+vn_decode_VkRect2D(struct vn_cs_decoder *dec, VkRect2D *val)
 {
-    /* skip val->{sType,pNext} */
-    vn_decode_uint64_t(dec, &val->drmFormatModifier);
+    vn_decode_VkOffset2D(dec, &val->offset);
+    vn_decode_VkExtent2D(dec, &val->extent);
 }
 
-static inline void
-vn_decode_VkImageDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val)
+static inline size_t
+vn_sizeof_VkRect2D_partial(const VkRect2D *val)
 {
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT);
+    size_t size = 0;
+    size += vn_sizeof_VkOffset2D_partial(&val->offset);
+    size += vn_sizeof_VkExtent2D_partial(&val->extent);
+    return size;
+}
 
-    assert(val->sType == stype);
-    vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(dec, val->pNext);
-    vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(dec, val);
+static inline void
+vn_encode_VkRect2D_partial(struct vn_cs_encoder *enc, const VkRect2D *val)
+{
+    vn_encode_VkOffset2D_partial(enc, &val->offset);
+    vn_encode_VkExtent2D_partial(enc, &val->extent);
 }
 
+/* struct VkMemoryDedicatedRequirements chain */
+
 static inline size_t
-vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(const void *val)
+vn_sizeof_VkMemoryDedicatedRequirements_pnext(const void *val)
 {
     /* no known/supported struct */
     return vn_sizeof_simple_pointer(NULL);
 }
 
 static inline size_t
-vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(const VkImageDrmFormatModifierPropertiesEXT *val)
+vn_sizeof_VkMemoryDedicatedRequirements_self(const VkMemoryDedicatedRequirements *val)
 {
     size_t size = 0;
     /* skip val->{sType,pNext} */
-    /* skip val->drmFormatModifier */
+    size += vn_sizeof_VkBool32(&val->prefersDedicatedAllocation);
+    size += vn_sizeof_VkBool32(&val->requiresDedicatedAllocation);
     return size;
 }
 
 static inline size_t
-vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(const VkImageDrmFormatModifierPropertiesEXT *val)
+vn_sizeof_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements *val)
 {
     size_t size = 0;
 
     size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(val->pNext);
-    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(val);
+    size += vn_sizeof_VkMemoryDedicatedRequirements_pnext(val->pNext);
+    size += vn_sizeof_VkMemoryDedicatedRequirements_self(val);
 
     return size;
 }
 
 static inline void
-vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+vn_decode_VkMemoryDedicatedRequirements_pnext(struct vn_cs_decoder *dec, const void *val)
 {
     /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
 }
 
 static inline void
-vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
+vn_decode_VkMemoryDedicatedRequirements_self(struct vn_cs_decoder *dec, VkMemoryDedicatedRequirements *val)
 {
     /* skip val->{sType,pNext} */
-    /* skip val->drmFormatModifier */
+    vn_decode_VkBool32(dec, &val->prefersDedicatedAllocation);
+    vn_decode_VkBool32(dec, &val->requiresDedicatedAllocation);
 }
 
 static inline void
-vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
+vn_decode_VkMemoryDedicatedRequirements(struct vn_cs_decoder *dec, VkMemoryDedicatedRequirements *val)
 {
-    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT });
-    vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(enc, val->pNext);
-    vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(enc, val);
-}
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
 
-/* struct VkBufferDeviceAddressInfo chain */
+    assert(val->sType == stype);
+    vn_decode_VkMemoryDedicatedRequirements_pnext(dec, val->pNext);
+    vn_decode_VkMemoryDedicatedRequirements_self(dec, val);
+}
 
 static inline size_t
-vn_sizeof_VkBufferDeviceAddressInfo_pnext(const void *val)
+vn_sizeof_VkMemoryDedicatedRequirements_pnext_partial(const void *val)
 {
     /* no known/supported struct */
     return vn_sizeof_simple_pointer(NULL);
 }
 
 static inline size_t
-vn_sizeof_VkBufferDeviceAddressInfo_self(const VkBufferDeviceAddressInfo *val)
+vn_sizeof_VkMemoryDedicatedRequirements_self_partial(const VkMemoryDedicatedRequirements *val)
 {
     size_t size = 0;
     /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkBuffer(&val->buffer);
+    /* skip val->prefersDedicatedAllocation */
+    /* skip val->requiresDedicatedAllocation */
     return size;
 }
 
 static inline size_t
-vn_sizeof_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo *val)
+vn_sizeof_VkMemoryDedicatedRequirements_partial(const VkMemoryDedicatedRequirements *val)
 {
     size_t size = 0;
 
     size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkBufferDeviceAddressInfo_pnext(val->pNext);
-    size += vn_sizeof_VkBufferDeviceAddressInfo_self(val);
+    size += vn_sizeof_VkMemoryDedicatedRequirements_pnext_partial(val->pNext);
+    size += vn_sizeof_VkMemoryDedicatedRequirements_self_partial(val);
 
     return size;
 }
 
 static inline void
-vn_encode_VkBufferDeviceAddressInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+vn_encode_VkMemoryDedicatedRequirements_pnext_partial(struct vn_cs_encoder *enc, const void *val)
 {
     /* no known/supported struct */
     vn_encode_simple_pointer(enc, NULL);
 }
 
 static inline void
-vn_encode_VkBufferDeviceAddressInfo_self(struct vn_cs_encoder *enc, const VkBufferDeviceAddressInfo *val)
+vn_encode_VkMemoryDedicatedRequirements_self_partial(struct vn_cs_encoder *enc, const VkMemoryDedicatedRequirements *val)
 {
     /* skip val->{sType,pNext} */
-    vn_encode_VkBuffer(enc, &val->buffer);
-}
-
-static inline void
-vn_encode_VkBufferDeviceAddressInfo(struct vn_cs_encoder *enc, const VkBufferDeviceAddressInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO });
-    vn_encode_VkBufferDeviceAddressInfo_pnext(enc, val->pNext);
-    vn_encode_VkBufferDeviceAddressInfo_self(enc, val);
+    /* skip val->prefersDedicatedAllocation */
+    /* skip val->requiresDedicatedAllocation */
 }
 
 static inline void
-vn_decode_VkBufferDeviceAddressInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+vn_encode_VkMemoryDedicatedRequirements_partial(struct vn_cs_encoder *enc, const VkMemoryDedicatedRequirements *val)
 {
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
-        assert(false);
+    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS });
+    vn_encode_VkMemoryDedicatedRequirements_pnext_partial(enc, val->pNext);
+    vn_encode_VkMemoryDedicatedRequirements_self_partial(enc, val);
 }
 
-static inline void
-vn_decode_VkBufferDeviceAddressInfo_self(struct vn_cs_decoder *dec, VkBufferDeviceAddressInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_decode_VkBuffer(dec, &val->buffer);
-}
+/* struct VkMemoryRequirements2 chain */
 
-static inline void
-vn_decode_VkBufferDeviceAddressInfo(struct vn_cs_decoder *dec, VkBufferDeviceAddressInfo *val)
+static inline size_t
+vn_sizeof_VkMemoryRequirements2_pnext(const void *val)
 {
-    VkStructureType stype;
-    vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO);
-
-    assert(val->sType == stype);
-    vn_decode_VkBufferDeviceAddressInfo_pnext(dec, val->pNext);
-    vn_decode_VkBufferDeviceAddressInfo_self(dec, val);
-}
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
 
-/* struct VkDeviceMemoryOpaqueCaptureAddressInfo chain */
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkMemoryRequirements2_pnext(pnext->pNext);
+            size += vn_sizeof_VkMemoryDedicatedRequirements_self((const VkMemoryDedicatedRequirements *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
 
-static inline size_t
-vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(const void *val)
-{
-    /* no known/supported struct */
     return vn_sizeof_simple_pointer(NULL);
 }
 
 static inline size_t
-vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_self(const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
+vn_sizeof_VkMemoryRequirements2_self(const VkMemoryRequirements2 *val)
 {
     size_t size = 0;
     /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkDeviceMemory(&val->memory);
+    size += vn_sizeof_VkMemoryRequirements(&val->memoryRequirements);
     return size;
 }
 
 static inline size_t
-vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
+vn_sizeof_VkMemoryRequirements2(const VkMemoryRequirements2 *val)
 {
     size_t size = 0;
 
     size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(val->pNext);
-    size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_self(val);
+    size += vn_sizeof_VkMemoryRequirements2_pnext(val->pNext);
+    size += vn_sizeof_VkMemoryRequirements2_self(val);
 
     return size;
 }
 
 static inline void
-vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+vn_decode_VkMemoryRequirements2_pnext(struct vn_cs_decoder *dec, const void *val)
 {
-    /* no known/supported struct */
-    vn_encode_simple_pointer(enc, NULL);
-}
+    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
+    VkStructureType stype;
 
-static inline void
-vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(struct vn_cs_encoder *enc, const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
-{
-    /* skip val->{sType,pNext} */
-    vn_encode_VkDeviceMemory(enc, &val->memory);
-}
+    if (!vn_decode_simple_pointer(dec))
+        return;
 
-static inline void
-vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo(struct vn_cs_encoder *enc, const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
-{
-    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO });
-    vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(enc, val->pNext);
-    vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(enc, val);
-}
+    vn_decode_VkStructureType(dec, &stype);
+    while (true) {
+        assert(pnext);
+        if (pnext->sType == stype)
+            break;
+    }
 
-static inline void
-vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(struct vn_cs_decoder *dec, const void *val)
-{
-    /* no known/supported struct */
-    if (vn_decode_simple_pointer(dec))
+    switch ((int32_t)pnext->sType) {
+    case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+        vn_decode_VkMemoryRequirements2_pnext(dec, pnext->pNext);
+        vn_decode_VkMemoryDedicatedRequirements_self(dec, (VkMemoryDedicatedRequirements *)pnext);
+        break;
+    default:
         assert(false);
+        break;
+    }
 }
 
 static inline void
-vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(struct vn_cs_decoder *dec, VkDeviceMemoryOpaqueCaptureAddressInfo *val)
+vn_decode_VkMemoryRequirements2_self(struct vn_cs_decoder *dec, VkMemoryRequirements2 *val)
 {
     /* skip val->{sType,pNext} */
-    vn_decode_VkDeviceMemory(dec, &val->memory);
+    vn_decode_VkMemoryRequirements(dec, &val->memoryRequirements);
 }
 
 static inline void
-vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo(struct vn_cs_decoder *dec, VkDeviceMemoryOpaqueCaptureAddressInfo *val)
+vn_decode_VkMemoryRequirements2(struct vn_cs_decoder *dec, VkMemoryRequirements2 *val)
 {
     VkStructureType stype;
     vn_decode_VkStructureType(dec, &stype);
-    assert(stype == VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO);
+    assert(stype == VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2);
 
     assert(val->sType == stype);
-    vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(dec, val->pNext);
-    vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(dec, val);
-}
-
-/* struct VkCommandStreamDescriptionMESA */
-
-static inline size_t
-vn_sizeof_VkCommandStreamDescriptionMESA(const VkCommandStreamDescriptionMESA *val)
-{
-    size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->resourceId);
-    size += vn_sizeof_size_t(&val->offset);
-    size += vn_sizeof_size_t(&val->size);
-    return size;
-}
-
-static inline void
-vn_encode_VkCommandStreamDescriptionMESA(struct vn_cs_encoder *enc, const VkCommandStreamDescriptionMESA *val)
-{
-    vn_encode_uint32_t(enc, &val->resourceId);
-    vn_encode_size_t(enc, &val->offset);
-    vn_encode_size_t(enc, &val->size);
+    vn_decode_VkMemoryRequirements2_pnext(dec, val->pNext);
+    vn_decode_VkMemoryRequirements2_self(dec, val);
 }
 
-/* struct VkCommandStreamDependencyMESA */
-
 static inline size_t
-vn_sizeof_VkCommandStreamDependencyMESA(const VkCommandStreamDependencyMESA *val)
+vn_sizeof_VkMemoryRequirements2_pnext_partial(const void *val)
 {
+    const VkBaseInStructure *pnext = val;
     size_t size = 0;
-    size += vn_sizeof_uint32_t(&val->srcCommandStream);
-    size += vn_sizeof_uint32_t(&val->dstCommandStream);
-    return size;
-}
 
-static inline void
-vn_encode_VkCommandStreamDependencyMESA(struct vn_cs_encoder *enc, const VkCommandStreamDependencyMESA *val)
-{
-    vn_encode_uint32_t(enc, &val->srcCommandStream);
-    vn_encode_uint32_t(enc, &val->dstCommandStream);
-}
-
-/* struct VkRingCreateInfoMESA chain */
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkMemoryRequirements2_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkMemoryDedicatedRequirements_self_partial((const VkMemoryDedicatedRequirements *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
 
-static inline size_t
-vn_sizeof_VkRingCreateInfoMESA_pnext(const void *val)
-{
-    /* no known/supported struct */
     return vn_sizeof_simple_pointer(NULL);
 }
 
 static inline size_t
-vn_sizeof_VkRingCreateInfoMESA_self(const VkRingCreateInfoMESA *val)
+vn_sizeof_VkMemoryRequirements2_self_partial(const VkMemoryRequirements2 *val)
 {
     size_t size = 0;
     /* skip val->{sType,pNext} */
-    size += vn_sizeof_VkFlags(&val->flags);
-    size += vn_sizeof_uint32_t(&val->resourceId);
-    size += vn_sizeof_size_t(&val->offset);
-    size += vn_sizeof_size_t(&val->size);
-    size += vn_sizeof_uint64_t(&val->idleTimeout);
-    size += vn_sizeof_size_t(&val->headOffset);
-    size += vn_sizeof_size_t(&val->tailOffset);
-    size += vn_sizeof_size_t(&val->statusOffset);
-    size += vn_sizeof_size_t(&val->bufferOffset);
-    size += vn_sizeof_size_t(&val->bufferSize);
-    size += vn_sizeof_size_t(&val->extraOffset);
-    size += vn_sizeof_size_t(&val->extraSize);
+    size += vn_sizeof_VkMemoryRequirements_partial(&val->memoryRequirements);
     return size;
 }
 
 static inline size_t
-vn_sizeof_VkRingCreateInfoMESA(const VkRingCreateInfoMESA *val)
+vn_sizeof_VkMemoryRequirements2_partial(const VkMemoryRequirements2 *val)
 {
     size_t size = 0;
 
     size += vn_sizeof_VkStructureType(&val->sType);
-    size += vn_sizeof_VkRingCreateInfoMESA_pnext(val->pNext);
-    size += vn_sizeof_VkRingCreateInfoMESA_self(val);
+    size += vn_sizeof_VkMemoryRequirements2_pnext_partial(val->pNext);
+    size += vn_sizeof_VkMemoryRequirements2_self_partial(val);
 
     return size;
 }
 
 static inline void
-vn_encode_VkRingCreateInfoMESA_pnext(struct vn_cs_encoder *enc, const void *val)
+vn_encode_VkMemoryRequirements2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
 {
-    /* no known/supported struct */
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkMemoryRequirements2_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkMemoryDedicatedRequirements_self_partial(enc, (const VkMemoryDedicatedRequirements *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
     vn_encode_simple_pointer(enc, NULL);
 }
 
 static inline void
-vn_encode_VkRingCreateInfoMESA_self(struct vn_cs_encoder *enc, const VkRingCreateInfoMESA *val)
+vn_encode_VkMemoryRequirements2_self_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements2 *val)
 {
     /* skip val->{sType,pNext} */
-    vn_encode_VkFlags(enc, &val->flags);
-    vn_encode_uint32_t(enc, &val->resourceId);
-    vn_encode_size_t(enc, &val->offset);
-    vn_encode_size_t(enc, &val->size);
-    vn_encode_uint64_t(enc, &val->idleTimeout);
-    vn_encode_size_t(enc, &val->headOffset);
-    vn_encode_size_t(enc, &val->tailOffset);
-    vn_encode_size_t(enc, &val->statusOffset);
-    vn_encode_size_t(enc, &val->bufferOffset);
-    vn_encode_size_t(enc, &val->bufferSize);
-    vn_encode_size_t(enc, &val->extraOffset);
-    vn_encode_size_t(enc, &val->extraSize);
+    vn_encode_VkMemoryRequirements_partial(enc, &val->memoryRequirements);
 }
 
 static inline void
-vn_encode_VkRingCreateInfoMESA(struct vn_cs_encoder *enc, const VkRingCreateInfoMESA *val)
+vn_encode_VkMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements2 *val)
 {
-    assert(val->sType == VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA);
-    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA });
-    vn_encode_VkRingCreateInfoMESA_pnext(enc, val->pNext);
-    vn_encode_VkRingCreateInfoMESA_self(enc, val);
+    assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 });
+    vn_encode_VkMemoryRequirements2_pnext_partial(enc, val->pNext);
+    vn_encode_VkMemoryRequirements2_self_partial(enc, val);
 }
 
-/*
- * Helpers for manual serialization
- */
-
 #endif /* VN_PROTOCOL_DRIVER_STRUCTS_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_transport.h b/src/virtio/venus-protocol/vn_protocol_driver_transport.h
new file mode 100644 (file)
index 0000000..02a203c
--- /dev/null
+++ b/src/virtio/venus-protocol/vn_protocol_driver_transport.h
@@ -0,0 +1,746 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_TRANSPORT_H
+#define VN_PROTOCOL_DRIVER_TRANSPORT_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkCommandStreamDescriptionMESA */
+
+static inline size_t
+vn_sizeof_VkCommandStreamDescriptionMESA(const VkCommandStreamDescriptionMESA *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->resourceId);
+    size += vn_sizeof_size_t(&val->offset);
+    size += vn_sizeof_size_t(&val->size);
+    return size;
+}
+
+static inline void
+vn_encode_VkCommandStreamDescriptionMESA(struct vn_cs_encoder *enc, const VkCommandStreamDescriptionMESA *val)
+{
+    vn_encode_uint32_t(enc, &val->resourceId);
+    vn_encode_size_t(enc, &val->offset);
+    vn_encode_size_t(enc, &val->size);
+}
+
+/* struct VkCommandStreamDependencyMESA */
+
+static inline size_t
+vn_sizeof_VkCommandStreamDependencyMESA(const VkCommandStreamDependencyMESA *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->srcCommandStream);
+    size += vn_sizeof_uint32_t(&val->dstCommandStream);
+    return size;
+}
+
+static inline void
+vn_encode_VkCommandStreamDependencyMESA(struct vn_cs_encoder *enc, const VkCommandStreamDependencyMESA *val)
+{
+    vn_encode_uint32_t(enc, &val->srcCommandStream);
+    vn_encode_uint32_t(enc, &val->dstCommandStream);
+}
+
+/* struct VkRingCreateInfoMESA chain */
+
+static inline size_t
+vn_sizeof_VkRingCreateInfoMESA_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkRingCreateInfoMESA_self(const VkRingCreateInfoMESA *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->resourceId);
+    size += vn_sizeof_size_t(&val->offset);
+    size += vn_sizeof_size_t(&val->size);
+    size += vn_sizeof_uint64_t(&val->idleTimeout);
+    size += vn_sizeof_size_t(&val->headOffset);
+    size += vn_sizeof_size_t(&val->tailOffset);
+    size += vn_sizeof_size_t(&val->statusOffset);
+    size += vn_sizeof_size_t(&val->bufferOffset);
+    size += vn_sizeof_size_t(&val->bufferSize);
+    size += vn_sizeof_size_t(&val->extraOffset);
+    size += vn_sizeof_size_t(&val->extraSize);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkRingCreateInfoMESA(const VkRingCreateInfoMESA *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkRingCreateInfoMESA_pnext(val->pNext);
+    size += vn_sizeof_VkRingCreateInfoMESA_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkRingCreateInfoMESA_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkRingCreateInfoMESA_self(struct vn_cs_encoder *enc, const VkRingCreateInfoMESA *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->resourceId);
+    vn_encode_size_t(enc, &val->offset);
+    vn_encode_size_t(enc, &val->size);
+    vn_encode_uint64_t(enc, &val->idleTimeout);
+    vn_encode_size_t(enc, &val->headOffset);
+    vn_encode_size_t(enc, &val->tailOffset);
+    vn_encode_size_t(enc, &val->statusOffset);
+    vn_encode_size_t(enc, &val->bufferOffset);
+    vn_encode_size_t(enc, &val->bufferSize);
+    vn_encode_size_t(enc, &val->extraOffset);
+    vn_encode_size_t(enc, &val->extraSize);
+}
+
+static inline void
+vn_encode_VkRingCreateInfoMESA(struct vn_cs_encoder *enc, const VkRingCreateInfoMESA *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA });
+    vn_encode_VkRingCreateInfoMESA_pnext(enc, val->pNext);
+    vn_encode_VkRingCreateInfoMESA_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkSetReplyCommandStreamMESA(const VkCommandStreamDescriptionMESA* pStream)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_simple_pointer(pStream);
+    if (pStream)
+        cmd_size += vn_sizeof_VkCommandStreamDescriptionMESA(pStream);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkSetReplyCommandStreamMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const VkCommandStreamDescriptionMESA* pStream)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    if (vn_encode_simple_pointer(enc, pStream))
+        vn_encode_VkCommandStreamDescriptionMESA(enc, pStream);
+}
+
+static inline size_t vn_sizeof_vkSetReplyCommandStreamMESA_reply(const VkCommandStreamDescriptionMESA* pStream)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip pStream */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkSetReplyCommandStreamMESA_reply(struct vn_cs_decoder *dec, const VkCommandStreamDescriptionMESA* pStream)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT);
+
+    /* skip pStream */
+}
+
+static inline size_t vn_sizeof_vkSeekReplyCommandStreamMESA(size_t position)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_size_t(&position);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkSeekReplyCommandStreamMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, size_t position)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_size_t(enc, &position);
+}
+
+static inline size_t vn_sizeof_vkSeekReplyCommandStreamMESA_reply(size_t position)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip position */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkSeekReplyCommandStreamMESA_reply(struct vn_cs_decoder *dec, size_t position)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT);
+
+    /* skip position */
+}
+
+static inline size_t vn_sizeof_vkExecuteCommandStreamsMESA(uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_uint32_t(&streamCount);
+    if (pStreams) {
+        cmd_size += vn_sizeof_array_size(streamCount);
+        for (uint32_t i = 0; i < streamCount; i++)
+            cmd_size += vn_sizeof_VkCommandStreamDescriptionMESA(&pStreams[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    if (pReplyPositions) {
+        cmd_size += vn_sizeof_array_size(streamCount);
+        cmd_size += vn_sizeof_size_t_array(pReplyPositions, streamCount);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_uint32_t(&dependencyCount);
+    if (pDependencies) {
+        cmd_size += vn_sizeof_array_size(dependencyCount);
+        for (uint32_t i = 0; i < dependencyCount; i++)
+            cmd_size += vn_sizeof_VkCommandStreamDependencyMESA(&pDependencies[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkExecuteCommandStreamsMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_uint32_t(enc, &streamCount);
+    if (pStreams) {
+        vn_encode_array_size(enc, streamCount);
+        for (uint32_t i = 0; i < streamCount; i++)
+            vn_encode_VkCommandStreamDescriptionMESA(enc, &pStreams[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (pReplyPositions) {
+        vn_encode_array_size(enc, streamCount);
+        vn_encode_size_t_array(enc, pReplyPositions, streamCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &dependencyCount);
+    if (pDependencies) {
+        vn_encode_array_size(enc, dependencyCount);
+        for (uint32_t i = 0; i < dependencyCount; i++)
+            vn_encode_VkCommandStreamDependencyMESA(enc, &pDependencies[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkExecuteCommandStreamsMESA_reply(uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip streamCount */
+    /* skip pStreams */
+    /* skip pReplyPositions */
+    /* skip dependencyCount */
+    /* skip pDependencies */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkExecuteCommandStreamsMESA_reply(struct vn_cs_decoder *dec, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT);
+
+    /* skip streamCount */
+    /* skip pStreams */
+    /* skip pReplyPositions */
+    /* skip dependencyCount */
+    /* skip pDependencies */
+    /* skip flags */
+}
+
+static inline size_t vn_sizeof_vkCreateRingMESA(uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_uint64_t(&ring);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkRingCreateInfoMESA(pCreateInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_uint64_t(enc, &ring);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkRingCreateInfoMESA(enc, pCreateInfo);
+}
+
+static inline size_t vn_sizeof_vkCreateRingMESA_reply(uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip ring */
+    /* skip pCreateInfo */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCreateRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateRingMESA_EXT);
+
+    /* skip ring */
+    /* skip pCreateInfo */
+}
+
+static inline size_t vn_sizeof_vkDestroyRingMESA(uint64_t ring)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_uint64_t(&ring);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_uint64_t(enc, &ring);
+}
+
+static inline size_t vn_sizeof_vkDestroyRingMESA_reply(uint64_t ring)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip ring */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyRingMESA_EXT);
+
+    /* skip ring */
+}
+
+static inline size_t vn_sizeof_vkNotifyRingMESA(uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_uint64_t(&ring);
+    cmd_size += vn_sizeof_uint32_t(&seqno);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkNotifyRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_uint64_t(enc, &ring);
+    vn_encode_uint32_t(enc, &seqno);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkNotifyRingMESA_reply(uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip ring */
+    /* skip seqno */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkNotifyRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkNotifyRingMESA_EXT);
+
+    /* skip ring */
+    /* skip seqno */
+    /* skip flags */
+}
+
+static inline size_t vn_sizeof_vkWriteRingExtraMESA(uint64_t ring, size_t offset, uint32_t value)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_uint64_t(&ring);
+    cmd_size += vn_sizeof_size_t(&offset);
+    cmd_size += vn_sizeof_uint32_t(&value);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkWriteRingExtraMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, size_t offset, uint32_t value)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_uint64_t(enc, &ring);
+    vn_encode_size_t(enc, &offset);
+    vn_encode_uint32_t(enc, &value);
+}
+
+static inline size_t vn_sizeof_vkWriteRingExtraMESA_reply(uint64_t ring, size_t offset, uint32_t value)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip ring */
+    /* skip offset */
+    /* skip value */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkWriteRingExtraMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, size_t offset, uint32_t value)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT);
+
+    /* skip ring */
+    /* skip offset */
+    /* skip value */
+}
+
+static inline void vn_submit_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const VkCommandStreamDescriptionMESA* pStream, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkSetReplyCommandStreamMESA(pStream);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkSetReplyCommandStreamMESA(&submit->command, cmd_flags, pStream);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetReplyCommandStreamMESA_reply(pStream) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, size_t position, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkSeekReplyCommandStreamMESA(position);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkSeekReplyCommandStreamMESA(&submit->command, cmd_flags, position);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSeekReplyCommandStreamMESA_reply(position) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkExecuteCommandStreamsMESA(streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkExecuteCommandStreamsMESA(&submit->command, cmd_flags, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkExecuteCommandStreamsMESA_reply(streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCreateRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateRingMESA(ring, pCreateInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateRingMESA(&submit->command, cmd_flags, ring, pCreateInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRingMESA_reply(ring, pCreateInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyRingMESA(ring);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyRingMESA(&submit->command, cmd_flags, ring);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRingMESA_reply(ring) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkNotifyRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkNotifyRingMESA(ring, seqno, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkNotifyRingMESA(&submit->command, cmd_flags, ring, seqno, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkNotifyRingMESA_reply(ring, seqno, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkWriteRingExtraMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, size_t offset, uint32_t value, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkWriteRingExtraMESA(ring, offset, value);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkWriteRingExtraMESA(&submit->command, cmd_flags, ring, offset, value);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWriteRingExtraMESA_reply(ring, offset, value) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_call_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, const VkCommandStreamDescriptionMESA* pStream)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSetReplyCommandStreamMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pStream, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkSetReplyCommandStreamMESA_reply(&submit.reply, pStream);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, const VkCommandStreamDescriptionMESA* pStream)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSetReplyCommandStreamMESA(vn_instance, 0, pStream, &submit);
+}
+
+static inline void vn_call_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, size_t position)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSeekReplyCommandStreamMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, position, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkSeekReplyCommandStreamMESA_reply(&submit.reply, position);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, size_t position)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSeekReplyCommandStreamMESA(vn_instance, 0, position, &submit);
+}
+
+static inline void vn_call_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkExecuteCommandStreamsMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkExecuteCommandStreamsMESA_reply(&submit.reply, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkExecuteCommandStreamsMESA(vn_instance, 0, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags, &submit);
+}
+
+static inline void vn_call_vkCreateRingMESA(struct vn_instance *vn_instance, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, pCreateInfo, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCreateRingMESA_reply(&submit.reply, ring, pCreateInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCreateRingMESA(struct vn_instance *vn_instance, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateRingMESA(vn_instance, 0, ring, pCreateInfo, &submit);
+}
+
+static inline void vn_call_vkDestroyRingMESA(struct vn_instance *vn_instance, uint64_t ring)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyRingMESA_reply(&submit.reply, ring);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyRingMESA(struct vn_instance *vn_instance, uint64_t ring)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyRingMESA(vn_instance, 0, ring, &submit);
+}
+
+static inline void vn_call_vkNotifyRingMESA(struct vn_instance *vn_instance, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkNotifyRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, seqno, flags, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkNotifyRingMESA_reply(&submit.reply, ring, seqno, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkNotifyRingMESA(struct vn_instance *vn_instance, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkNotifyRingMESA(vn_instance, 0, ring, seqno, flags, &submit);
+}
+
+static inline void vn_call_vkWriteRingExtraMESA(struct vn_instance *vn_instance, uint64_t ring, size_t offset, uint32_t value)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWriteRingExtraMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, offset, value, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkWriteRingExtraMESA_reply(&submit.reply, ring, offset, value);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkWriteRingExtraMESA(struct vn_instance *vn_instance, uint64_t ring, size_t offset, uint32_t value)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWriteRingExtraMESA(vn_instance, 0, ring, offset, value, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_TRANSPORT_H */

diff --git a/src/virtio/venus-protocol/vn_protocol_driver_types.h b/src/virtio/venus-protocol/vn_protocol_driver_types.h
index 5ce2837..bfea8f6 100644 (file)
--- a/src/virtio/venus-protocol/vn_protocol_driver_types.h
+++ b/src/virtio/venus-protocol/vn_protocol_driver_types.h
@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC