diff --git a/system/vulkan/func_table.cpp b/system/vulkan/func_table.cpp
index 44faf95..6dfaa68 100644
--- a/system/vulkan/func_table.cpp
+++ b/system/vulkan/func_table.cpp
@@ -163,7 +163,8 @@
 {
     auto vkEnc = HostConnection::get()->vkEncoder();
     VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
-    vkEnumerateInstanceExtensionProperties_VkResult_return = vkEnc->vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
+    auto resources = ResourceTracker::get();
+    vkEnumerateInstanceExtensionProperties_VkResult_return = resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, pLayerName, pPropertyCount, pProperties);
     return vkEnumerateInstanceExtensionProperties_VkResult_return;
 }
 static VkResult entry_vkEnumerateDeviceExtensionProperties(
@@ -174,7 +175,8 @@
 {
     auto vkEnc = HostConnection::get()->vkEncoder();
     VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
-    vkEnumerateDeviceExtensionProperties_VkResult_return = vkEnc->vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
+    auto resources = ResourceTracker::get();
+    vkEnumerateDeviceExtensionProperties_VkResult_return = resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physicalDevice, pLayerName, pPropertyCount, pProperties);
     return vkEnumerateDeviceExtensionProperties_VkResult_return;
 }
 static VkResult entry_vkEnumerateInstanceLayerProperties(
diff --git a/system/vulkan/goldfish_vulkan.cpp b/system/vulkan/goldfish_vulkan.cpp
index 8064dfb..155fbe9 100644
--- a/system/vulkan/goldfish_vulkan.cpp
+++ b/system/vulkan/goldfish_vulkan.cpp
@@ -82,18 +82,10 @@
             layer_name);
     }
 
-    // For now, let's not expose any extensions;
-    // add them one at a time as needed.
-    *count = 1;
-    VkExtensionProperties anb = {
-        "VK_ANDROID_native_buffer", 7,
-    };
+    VkResult res = goldfish_vk::ResourceTracker::get()->on_vkEnumerateInstanceExtensionProperties(
+        vkEnc, VK_SUCCESS, layer_name, count, properties);
 
-    if (properties) {
-        *properties = anb;
-    }
-
-    return VK_SUCCESS;
+    return res;
 }
 
 VKAPI_ATTR
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
index 860c03d..a1b8c14 100644
--- a/system/vulkan_enc/ResourceTracker.cpp
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -27,6 +27,7 @@
 #include "goldfish_address_space.h"
 #include "goldfish_vk_private_defs.h"
 
+#include <string>
 #include <unordered_map>
 
 #include <log/log.h>
@@ -286,6 +287,28 @@
         return mHostVisibleMemoryVirtInfo.virtualizationSupported;
     }
 
+    int getHostInstanceExtensionIndex(const std::string& extName) const {
+        int i = 0;
+        for (const auto& prop : mHostInstanceExtensions) {
+            if (extName == std::string(prop.extensionName)) {
+                return i;
+            }
+            ++i;
+        }
+        return -1;
+    }
+
+    int getHostDeviceExtensionIndex(const std::string& extName) const {
+        int i = 0;
+        for (const auto& prop : mHostDeviceExtensions) {
+            if (extName == std::string(prop.extensionName)) {
+                return i;
+            }
+            ++i;
+        }
+        return -1;
+    }
+
     void deviceMemoryTransform_tohost(
         VkDeviceMemory* memory, uint32_t memoryCount,
         VkDeviceSize* offset, uint32_t offsetCount,
@@ -407,30 +430,122 @@
         return VK_SUCCESS;
     }
 
-    VkResult on_vkEnumerateDeviceExtensionProperties(
-        void*,
+    VkResult on_vkEnumerateInstanceExtensionProperties(
+        void* context,
         VkResult,
-        VkPhysicalDevice,
         const char*,
         uint32_t* pPropertyCount,
         VkExtensionProperties* pProperties) {
-        *pPropertyCount = 1;
-    VkExtensionProperties anb = {
-        "VK_ANDROID_native_buffer", 7,
-    };
 
-    if (pProperties) {
-        *pProperties = anb;
-    }
+        std::vector<const char*> allowedExtensionNames = {
+            "VK_KHR_get_physical_device_properties2",
+            // TODO:
+            // VK_KHR_external_memory_capabilities
+        };
+
+        VkEncoder* enc = (VkEncoder*)context;
+
+        // Only advertise a select set of extensions.
+        if (mHostInstanceExtensions.empty()) {
+            uint32_t hostPropCount = 0;
+            enc->vkEnumerateInstanceExtensionProperties(nullptr, &hostPropCount, nullptr);
+            mHostInstanceExtensions.resize(hostPropCount);
+
+            VkResult hostRes =
+                enc->vkEnumerateInstanceExtensionProperties(
+                    nullptr, &hostPropCount, mHostInstanceExtensions.data());
+
+            if (hostRes != VK_SUCCESS) {
+                return hostRes;
+            }
+        }
+
+        std::vector<VkExtensionProperties> filteredExts;
+
+        for (size_t i = 0; i < allowedExtensionNames.size(); ++i) {
+            auto extIndex = getHostInstanceExtensionIndex(allowedExtensionNames[i]);
+            if (extIndex != -1) {
+                filteredExts.push_back(mHostInstanceExtensions[extIndex]);
+            }
+        }
+
+        VkExtensionProperties anbExtProp = {
+            "VK_ANDROID_native_buffer", 7,
+        };
+
+        filteredExts.push_back(anbExtProp);
+
+        if (pPropertyCount) {
+            *pPropertyCount = filteredExts.size();
+        }
+
+        if (pPropertyCount && pProperties) {
+            for (size_t i = 0; i < *pPropertyCount; ++i) {
+                pProperties[i] = filteredExts[i];
+            }
+        }
 
         return VK_SUCCESS;
     }
 
-    void on_vkGetPhysicalDeviceProperties2(
-        void*,
-        VkPhysicalDevice,
-        VkPhysicalDeviceProperties2*) {
-        // no-op
+    VkResult on_vkEnumerateDeviceExtensionProperties(
+        void* context,
+        VkResult,
+        VkPhysicalDevice physdev,
+        const char*,
+        uint32_t* pPropertyCount,
+        VkExtensionProperties* pProperties) {
+
+        std::vector<const char*> allowedExtensionNames = {
+            // "VK_KHR_maintenance1",
+            // "VK_KHR_maintenance2",
+            // "VK_KHR_maintenance3",
+            // TODO:
+            // VK_KHR_external_memory_capabilities
+        };
+
+        VkEncoder* enc = (VkEncoder*)context;
+
+        if (mHostDeviceExtensions.empty()) {
+            uint32_t hostPropCount = 0;
+            enc->vkEnumerateDeviceExtensionProperties(physdev, nullptr, &hostPropCount, nullptr);
+            mHostDeviceExtensions.resize(hostPropCount);
+
+            VkResult hostRes =
+                enc->vkEnumerateDeviceExtensionProperties(
+                    physdev, nullptr, &hostPropCount, mHostDeviceExtensions.data());
+
+            if (hostRes != VK_SUCCESS) {
+                return hostRes;
+            }
+        }
+
+        std::vector<VkExtensionProperties> filteredExts;
+
+        for (size_t i = 0; i < allowedExtensionNames.size(); ++i) {
+            auto extIndex = getHostDeviceExtensionIndex(allowedExtensionNames[i]);
+            if (extIndex != -1) {
+                filteredExts.push_back(mHostDeviceExtensions[extIndex]);
+            }
+        }
+
+        VkExtensionProperties anbExtProp = {
+            "VK_ANDROID_native_buffer", 7,
+        };
+
+        filteredExts.push_back(anbExtProp);
+
+        if (pPropertyCount) {
+            *pPropertyCount = filteredExts.size();
+        }
+
+        if (pPropertyCount && pProperties) {
+            for (size_t i = 0; i < *pPropertyCount; ++i) {
+                pProperties[i] = filteredExts[i];
+            }
+        }
+
+        return VK_SUCCESS;
     }
 
     void on_vkGetPhysicalDeviceMemoryProperties(
@@ -449,6 +564,23 @@
         }
     }
 
+    void on_vkGetPhysicalDeviceMemoryProperties2(
+        void*,
+        VkPhysicalDevice physdev,
+        VkPhysicalDeviceMemoryProperties2* out) {
+
+        initHostVisibleMemoryVirtualizationInfo(
+            physdev,
+            &out->memoryProperties,
+            mFeatureInfo->hasDirectMem,
+            &mHostVisibleMemoryVirtInfo);
+
+        if (mHostVisibleMemoryVirtInfo.virtualizationSupported) {
+            out->memoryProperties = mHostVisibleMemoryVirtInfo.guestMemoryProperties;
+        }
+    }
+
+
     VkResult on_vkCreateDevice(
         void* context,
         VkResult input_result,
@@ -831,7 +963,11 @@
     HostVisibleMemoryVirtualizationInfo mHostVisibleMemoryVirtInfo;
     std::unique_ptr<EmulatorFeatureInfo> mFeatureInfo;
     std::unique_ptr<GoldfishAddressSpaceBlockProvider> mGoldfishAddressSpaceBlockProvider;
+
+    std::vector<VkExtensionProperties> mHostInstanceExtensions;
+    std::vector<VkExtensionProperties> mHostDeviceExtensions;
 };
+
 ResourceTracker::ResourceTracker() : mImpl(new ResourceTracker::Impl()) { }
 ResourceTracker::~ResourceTracker() { }
 VulkanHandleMapping* ResourceTracker::createMapping() {
@@ -938,6 +1074,16 @@
     return mImpl->on_vkEnumerateInstanceVersion(context, input_result, apiVersion);
 }
 
+VkResult ResourceTracker::on_vkEnumerateInstanceExtensionProperties(
+    void* context,
+    VkResult input_result,
+    const char* pLayerName,
+    uint32_t* pPropertyCount,
+    VkExtensionProperties* pProperties) {
+    return mImpl->on_vkEnumerateInstanceExtensionProperties(
+        context, input_result, pLayerName, pPropertyCount, pProperties);
+}
+
 VkResult ResourceTracker::on_vkEnumerateDeviceExtensionProperties(
     void* context,
     VkResult input_result,
@@ -949,13 +1095,6 @@
         context, input_result, physicalDevice, pLayerName, pPropertyCount, pProperties);
 }
 
-void ResourceTracker::on_vkGetPhysicalDeviceProperties2(
-    void* context,
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceProperties2* pProperties) {
-    mImpl->on_vkGetPhysicalDeviceProperties2(context, physicalDevice, pProperties);
-}
-
 void ResourceTracker::on_vkGetPhysicalDeviceMemoryProperties(
     void* context,
     VkPhysicalDevice physicalDevice,
@@ -964,6 +1103,22 @@
         context, physicalDevice, pMemoryProperties);
 }
 
+void ResourceTracker::on_vkGetPhysicalDeviceMemoryProperties2(
+    void* context,
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
+    mImpl->on_vkGetPhysicalDeviceMemoryProperties2(
+        context, physicalDevice, pMemoryProperties);
+}
+
+void ResourceTracker::on_vkGetPhysicalDeviceMemoryProperties2KHR(
+    void* context,
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
+    mImpl->on_vkGetPhysicalDeviceMemoryProperties2(
+        context, physicalDevice, pMemoryProperties);
+}
+
 VkResult ResourceTracker::on_vkCreateDevice(
     void* context,
     VkResult input_result,
diff --git a/system/vulkan_enc/ResourceTracker.h b/system/vulkan_enc/ResourceTracker.h
index 6ad0ef1..7fecee2 100644
--- a/system/vulkan_enc/ResourceTracker.h
+++ b/system/vulkan_enc/ResourceTracker.h
@@ -44,6 +44,14 @@
         void* context,
         VkResult input_result,
         uint32_t* apiVersion);
+
+    VkResult on_vkEnumerateInstanceExtensionProperties(
+        void* context,
+        VkResult input_result,
+        const char* pLayerName,
+        uint32_t* pPropertyCount,
+        VkExtensionProperties* pProperties);
+
     VkResult on_vkEnumerateDeviceExtensionProperties(
         void* context,
         VkResult input_result,
@@ -51,14 +59,19 @@
         const char* pLayerName,
         uint32_t* pPropertyCount,
         VkExtensionProperties* pProperties);
-    void on_vkGetPhysicalDeviceProperties2(
-        void* context,
-        VkPhysicalDevice physicalDevice,
-        VkPhysicalDeviceProperties2* pProperties);
+
     void on_vkGetPhysicalDeviceMemoryProperties(
         void* context,
         VkPhysicalDevice physicalDevice,
         VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+    void on_vkGetPhysicalDeviceMemoryProperties2(
+        void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+    void on_vkGetPhysicalDeviceMemoryProperties2KHR(
+        void* context,
+        VkPhysicalDevice physicalDevice,
+        VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
 
     VkResult on_vkCreateDevice(
         void* context,
@@ -144,4 +157,4 @@
     std::unique_ptr<Impl> mImpl;
 };
 
-} // namespace goldfish_vk
+} // namespace goldfish_vk
\ No newline at end of file
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
index b582114..d42d9be 100644
--- a/system/vulkan_enc/VkEncoder.cpp
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -992,8 +992,107 @@
     uint32_t* pPropertyCount,
     VkExtensionProperties* pProperties)
 {
+    mImpl->log("start vkEnumerateDeviceExtensionProperties");
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    char* local_pLayerName;
+    local_physicalDevice = physicalDevice;
+    local_pLayerName = nullptr;
+    if (pLayerName)
+    {
+        local_pLayerName = pool->strDup(pLayerName);
+    }
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_59;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_59, 1);
+        countingStream->write((uint64_t*)&cgen_var_59, 1 * 8);
+        countingStream->putString(local_pLayerName);
+        // WARNING PTR CHECK
+        uint64_t cgen_var_60 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_60);
+        if (pPropertyCount)
+        {
+            countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+        }
+        // WARNING PTR CHECK
+        uint64_t cgen_var_61 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_61);
+        if (pProperties)
+        {
+            for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+            {
+                marshal_VkExtensionProperties(countingStream, (VkExtensionProperties*)(pProperties + i));
+            }
+        }
+    }
+    uint32_t packetSize_vkEnumerateDeviceExtensionProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkEnumerateDeviceExtensionProperties = OP_vkEnumerateDeviceExtensionProperties;
+    stream->write(&opcode_vkEnumerateDeviceExtensionProperties, sizeof(uint32_t));
+    stream->write(&packetSize_vkEnumerateDeviceExtensionProperties, sizeof(uint32_t));
+    uint64_t cgen_var_62;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_62, 1);
+    stream->write((uint64_t*)&cgen_var_62, 1 * 8);
+    stream->putString(local_pLayerName);
+    // WARNING PTR CHECK
+    uint64_t cgen_var_63 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_63);
+    if (pPropertyCount)
+    {
+        stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_64 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_64);
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            marshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint32_t* check_pPropertyCount;
+    check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+    if (pPropertyCount)
+    {
+        if (!(check_pPropertyCount))
+        {
+            fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+        }
+        stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+    }
+    // WARNING PTR CHECK
+    VkExtensionProperties* check_pProperties;
+    check_pProperties = (VkExtensionProperties*)(uintptr_t)stream->getBe64();
+    if (pProperties)
+    {
+        if (!(check_pProperties))
+        {
+            fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+        }
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            unmarshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i));
+        }
+    }
+    if (pProperties)
+    {
+        for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+        {
+            transform_fromhost_VkExtensionProperties(mImpl->resources(), (VkExtensionProperties*)(pProperties + i));
+        }
+    }
     VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
-    vkEnumerateDeviceExtensionProperties_VkResult_return = mImpl->resources()->on_vkEnumerateDeviceExtensionProperties(this, VK_SUCCESS, physicalDevice, pLayerName, pPropertyCount, pProperties);
+    stream->read(&vkEnumerateDeviceExtensionProperties_VkResult_return, sizeof(VkResult));
+    countingStream->clearPool();
+    stream->clearPool();
+    pool->freeAll();
     mImpl->log("finish vkEnumerateDeviceExtensionProperties");;
     return vkEnumerateDeviceExtensionProperties_VkResult_return;
 }
@@ -1011,15 +1110,15 @@
     countingStream->rewind();
     {
         // WARNING PTR CHECK
-        uint64_t cgen_var_59 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_59);
+        uint64_t cgen_var_67 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_67);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_60 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_60);
+        uint64_t cgen_var_68 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_68);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1034,15 +1133,15 @@
     stream->write(&opcode_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
     stream->write(&packetSize_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_61 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_61);
+    uint64_t cgen_var_69 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_69);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_62 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_62);
+    uint64_t cgen_var_70 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_70);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1106,19 +1205,19 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_65;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_65, 1);
-        countingStream->write((uint64_t*)&cgen_var_65, 1 * 8);
+        uint64_t cgen_var_73;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_73, 1);
+        countingStream->write((uint64_t*)&cgen_var_73, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_66 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_66);
+        uint64_t cgen_var_74 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_74);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_67 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_67);
+        uint64_t cgen_var_75 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_75);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1132,19 +1231,19 @@
     uint32_t opcode_vkEnumerateDeviceLayerProperties = OP_vkEnumerateDeviceLayerProperties;
     stream->write(&opcode_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
     stream->write(&packetSize_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
-    uint64_t cgen_var_68;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_68, 1);
-    stream->write((uint64_t*)&cgen_var_68, 1 * 8);
+    uint64_t cgen_var_76;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_76, 1);
+    stream->write((uint64_t*)&cgen_var_76, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_69 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_69);
+    uint64_t cgen_var_77 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_77);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_70 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_70);
+    uint64_t cgen_var_78 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_78);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1213,34 +1312,34 @@
     local_queueIndex = queueIndex;
     countingStream->rewind();
     {
-        uint64_t cgen_var_73;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_73, 1);
-        countingStream->write((uint64_t*)&cgen_var_73, 1 * 8);
+        uint64_t cgen_var_81;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_81, 1);
+        countingStream->write((uint64_t*)&cgen_var_81, 1 * 8);
         countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_queueIndex, sizeof(uint32_t));
-        uint64_t cgen_var_74;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_74, 1);
-        countingStream->write((uint64_t*)&cgen_var_74, 8);
+        uint64_t cgen_var_82;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_82, 1);
+        countingStream->write((uint64_t*)&cgen_var_82, 8);
     }
     uint32_t packetSize_vkGetDeviceQueue = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkGetDeviceQueue = OP_vkGetDeviceQueue;
     stream->write(&opcode_vkGetDeviceQueue, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDeviceQueue, sizeof(uint32_t));
-    uint64_t cgen_var_75;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_75, 1);
-    stream->write((uint64_t*)&cgen_var_75, 1 * 8);
+    uint64_t cgen_var_83;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_83, 1);
+    stream->write((uint64_t*)&cgen_var_83, 1 * 8);
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     stream->write((uint32_t*)&local_queueIndex, sizeof(uint32_t));
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_76;
-    stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_76, 1);
-    stream->write((uint64_t*)&cgen_var_76, 8);
+    uint64_t cgen_var_84;
+    stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_84, 1);
+    stream->write((uint64_t*)&cgen_var_84, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_77;
-    stream->read((uint64_t*)&cgen_var_77, 8);
-    stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_77, (VkQueue*)pQueue, 1);
+    uint64_t cgen_var_85;
+    stream->read((uint64_t*)&cgen_var_85, 8);
+    stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_85, (VkQueue*)pQueue, 1);
     stream->unsetHandleMapping();
     mImpl->log("finish vkGetDeviceQueue");;
 }
@@ -1282,34 +1381,34 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_78;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_78, 1);
-        countingStream->write((uint64_t*)&cgen_var_78, 1 * 8);
+        uint64_t cgen_var_86;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_86, 1);
+        countingStream->write((uint64_t*)&cgen_var_86, 1 * 8);
         countingStream->write((uint32_t*)&local_submitCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
         {
             marshal_VkSubmitInfo(countingStream, (VkSubmitInfo*)(local_pSubmits + i));
         }
-        uint64_t cgen_var_79;
-        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_79, 1);
-        countingStream->write((uint64_t*)&cgen_var_79, 1 * 8);
+        uint64_t cgen_var_87;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_87, 1);
+        countingStream->write((uint64_t*)&cgen_var_87, 1 * 8);
     }
     uint32_t packetSize_vkQueueSubmit = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkQueueSubmit = OP_vkQueueSubmit;
     stream->write(&opcode_vkQueueSubmit, sizeof(uint32_t));
     stream->write(&packetSize_vkQueueSubmit, sizeof(uint32_t));
-    uint64_t cgen_var_80;
-    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_80, 1);
-    stream->write((uint64_t*)&cgen_var_80, 1 * 8);
+    uint64_t cgen_var_88;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_88, 1);
+    stream->write((uint64_t*)&cgen_var_88, 1 * 8);
     stream->write((uint32_t*)&local_submitCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
     {
         marshal_VkSubmitInfo(stream, (VkSubmitInfo*)(local_pSubmits + i));
     }
-    uint64_t cgen_var_81;
-    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_81, 1);
-    stream->write((uint64_t*)&cgen_var_81, 1 * 8);
+    uint64_t cgen_var_89;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_89, 1);
+    stream->write((uint64_t*)&cgen_var_89, 1 * 8);
     VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
     stream->read(&vkQueueSubmit_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -1332,18 +1431,18 @@
     local_queue = queue;
     countingStream->rewind();
     {
-        uint64_t cgen_var_82;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_82, 1);
-        countingStream->write((uint64_t*)&cgen_var_82, 1 * 8);
+        uint64_t cgen_var_90;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_90, 1);
+        countingStream->write((uint64_t*)&cgen_var_90, 1 * 8);
     }
     uint32_t packetSize_vkQueueWaitIdle = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkQueueWaitIdle = OP_vkQueueWaitIdle;
     stream->write(&opcode_vkQueueWaitIdle, sizeof(uint32_t));
     stream->write(&packetSize_vkQueueWaitIdle, sizeof(uint32_t));
-    uint64_t cgen_var_83;
-    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_83, 1);
-    stream->write((uint64_t*)&cgen_var_83, 1 * 8);
+    uint64_t cgen_var_91;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_91, 1);
+    stream->write((uint64_t*)&cgen_var_91, 1 * 8);
     VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
     stream->read(&vkQueueWaitIdle_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -1366,18 +1465,18 @@
     local_device = device;
     countingStream->rewind();
     {
-        uint64_t cgen_var_84;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_84, 1);
-        countingStream->write((uint64_t*)&cgen_var_84, 1 * 8);
+        uint64_t cgen_var_92;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_92, 1);
+        countingStream->write((uint64_t*)&cgen_var_92, 1 * 8);
     }
     uint32_t packetSize_vkDeviceWaitIdle = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkDeviceWaitIdle = OP_vkDeviceWaitIdle;
     stream->write(&opcode_vkDeviceWaitIdle, sizeof(uint32_t));
     stream->write(&packetSize_vkDeviceWaitIdle, sizeof(uint32_t));
-    uint64_t cgen_var_85;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_85, 1);
-    stream->write((uint64_t*)&cgen_var_85, 1 * 8);
+    uint64_t cgen_var_93;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_93, 1);
+    stream->write((uint64_t*)&cgen_var_93, 1 * 8);
     VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
     stream->read(&vkDeviceWaitIdle_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -1426,46 +1525,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_86;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_86, 1);
-        countingStream->write((uint64_t*)&cgen_var_86, 1 * 8);
+        uint64_t cgen_var_94;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_94, 1);
+        countingStream->write((uint64_t*)&cgen_var_94, 1 * 8);
         marshal_VkMemoryAllocateInfo(countingStream, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_87 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_87);
+        uint64_t cgen_var_95 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_95);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_88;
-        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_88, 1);
-        countingStream->write((uint64_t*)&cgen_var_88, 8);
+        uint64_t cgen_var_96;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_96, 1);
+        countingStream->write((uint64_t*)&cgen_var_96, 8);
     }
     uint32_t packetSize_vkAllocateMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkAllocateMemory = OP_vkAllocateMemory;
     stream->write(&opcode_vkAllocateMemory, sizeof(uint32_t));
     stream->write(&packetSize_vkAllocateMemory, sizeof(uint32_t));
-    uint64_t cgen_var_89;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_89, 1);
-    stream->write((uint64_t*)&cgen_var_89, 1 * 8);
+    uint64_t cgen_var_97;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_97, 1);
+    stream->write((uint64_t*)&cgen_var_97, 1 * 8);
     marshal_VkMemoryAllocateInfo(stream, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_90 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_90);
+    uint64_t cgen_var_98 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_98);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_91;
-    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_91, 1);
-    stream->write((uint64_t*)&cgen_var_91, 8);
+    uint64_t cgen_var_99;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_99, 1);
+    stream->write((uint64_t*)&cgen_var_99, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_92;
-    stream->read((uint64_t*)&cgen_var_92, 8);
-    stream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_92, (VkDeviceMemory*)pMemory, 1);
+    uint64_t cgen_var_100;
+    stream->read((uint64_t*)&cgen_var_100, 8);
+    stream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_100, (VkDeviceMemory*)pMemory, 1);
     stream->unsetHandleMapping();
     VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
     stream->read(&vkAllocateMemory_VkResult_return, sizeof(VkResult));
@@ -1502,15 +1601,15 @@
     mImpl->resources()->deviceMemoryTransform_tohost(&local_memory, 1, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0);
     countingStream->rewind();
     {
-        uint64_t cgen_var_93;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_93, 1);
-        countingStream->write((uint64_t*)&cgen_var_93, 1 * 8);
-        uint64_t cgen_var_94;
-        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_94, 1);
-        countingStream->write((uint64_t*)&cgen_var_94, 1 * 8);
+        uint64_t cgen_var_101;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_101, 1);
+        countingStream->write((uint64_t*)&cgen_var_101, 1 * 8);
+        uint64_t cgen_var_102;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_102, 1);
+        countingStream->write((uint64_t*)&cgen_var_102, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_95 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_95);
+        uint64_t cgen_var_103 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_103);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -1521,15 +1620,15 @@
     uint32_t opcode_vkFreeMemory = OP_vkFreeMemory;
     stream->write(&opcode_vkFreeMemory, sizeof(uint32_t));
     stream->write(&packetSize_vkFreeMemory, sizeof(uint32_t));
-    uint64_t cgen_var_96;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_96, 1);
-    stream->write((uint64_t*)&cgen_var_96, 1 * 8);
-    uint64_t cgen_var_97;
-    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_97, 1);
-    stream->write((uint64_t*)&cgen_var_97, 1 * 8);
+    uint64_t cgen_var_104;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_104, 1);
+    stream->write((uint64_t*)&cgen_var_104, 1 * 8);
+    uint64_t cgen_var_105;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_105, 1);
+    stream->write((uint64_t*)&cgen_var_105, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_98 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_98);
+    uint64_t cgen_var_106 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_106);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -1594,9 +1693,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_99;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_99, 1);
-        countingStream->write((uint64_t*)&cgen_var_99, 1 * 8);
+        uint64_t cgen_var_107;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_107, 1);
+        countingStream->write((uint64_t*)&cgen_var_107, 1 * 8);
         countingStream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
         {
@@ -1627,9 +1726,9 @@
     uint32_t opcode_vkFlushMappedMemoryRanges = OP_vkFlushMappedMemoryRanges;
     stream->write(&opcode_vkFlushMappedMemoryRanges, sizeof(uint32_t));
     stream->write(&packetSize_vkFlushMappedMemoryRanges, sizeof(uint32_t));
-    uint64_t cgen_var_100;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_100, 1);
-    stream->write((uint64_t*)&cgen_var_100, 1 * 8);
+    uint64_t cgen_var_108;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_108, 1);
+    stream->write((uint64_t*)&cgen_var_108, 1 * 8);
     stream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
     {
@@ -1698,9 +1797,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_101;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_101, 1);
-        countingStream->write((uint64_t*)&cgen_var_101, 1 * 8);
+        uint64_t cgen_var_109;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_109, 1);
+        countingStream->write((uint64_t*)&cgen_var_109, 1 * 8);
         countingStream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
         {
@@ -1712,9 +1811,9 @@
     uint32_t opcode_vkInvalidateMappedMemoryRanges = OP_vkInvalidateMappedMemoryRanges;
     stream->write(&opcode_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
     stream->write(&packetSize_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
-    uint64_t cgen_var_102;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_102, 1);
-    stream->write((uint64_t*)&cgen_var_102, 1 * 8);
+    uint64_t cgen_var_110;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_110, 1);
+    stream->write((uint64_t*)&cgen_var_110, 1 * 8);
     stream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
     {
@@ -1766,12 +1865,12 @@
     mImpl->resources()->deviceMemoryTransform_tohost(&local_memory, 1, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0);
     countingStream->rewind();
     {
-        uint64_t cgen_var_103;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_103, 1);
-        countingStream->write((uint64_t*)&cgen_var_103, 1 * 8);
-        uint64_t cgen_var_104;
-        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_104, 1);
-        countingStream->write((uint64_t*)&cgen_var_104, 1 * 8);
+        uint64_t cgen_var_111;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_111, 1);
+        countingStream->write((uint64_t*)&cgen_var_111, 1 * 8);
+        uint64_t cgen_var_112;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_112, 1);
+        countingStream->write((uint64_t*)&cgen_var_112, 1 * 8);
         countingStream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
     }
     uint32_t packetSize_vkGetDeviceMemoryCommitment = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -1779,12 +1878,12 @@
     uint32_t opcode_vkGetDeviceMemoryCommitment = OP_vkGetDeviceMemoryCommitment;
     stream->write(&opcode_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
-    uint64_t cgen_var_105;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_105, 1);
-    stream->write((uint64_t*)&cgen_var_105, 1 * 8);
-    uint64_t cgen_var_106;
-    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_106, 1);
-    stream->write((uint64_t*)&cgen_var_106, 1 * 8);
+    uint64_t cgen_var_113;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_113, 1);
+    stream->write((uint64_t*)&cgen_var_113, 1 * 8);
+    uint64_t cgen_var_114;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_114, 1);
+    stream->write((uint64_t*)&cgen_var_114, 1 * 8);
     stream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
     stream->read((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
     mImpl->log("finish vkGetDeviceMemoryCommitment");;
@@ -1813,15 +1912,15 @@
     mImpl->resources()->deviceMemoryTransform_tohost(&local_memory, 1, &local_memoryOffset, 1, nullptr, 0, nullptr, 0, nullptr, 0);
     countingStream->rewind();
     {
-        uint64_t cgen_var_107;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_107, 1);
-        countingStream->write((uint64_t*)&cgen_var_107, 1 * 8);
-        uint64_t cgen_var_108;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_108, 1);
-        countingStream->write((uint64_t*)&cgen_var_108, 1 * 8);
-        uint64_t cgen_var_109;
-        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_109, 1);
-        countingStream->write((uint64_t*)&cgen_var_109, 1 * 8);
+        uint64_t cgen_var_115;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_115, 1);
+        countingStream->write((uint64_t*)&cgen_var_115, 1 * 8);
+        uint64_t cgen_var_116;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_116, 1);
+        countingStream->write((uint64_t*)&cgen_var_116, 1 * 8);
+        uint64_t cgen_var_117;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_117, 1);
+        countingStream->write((uint64_t*)&cgen_var_117, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
     }
     uint32_t packetSize_vkBindBufferMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -1829,15 +1928,15 @@
     uint32_t opcode_vkBindBufferMemory = OP_vkBindBufferMemory;
     stream->write(&opcode_vkBindBufferMemory, sizeof(uint32_t));
     stream->write(&packetSize_vkBindBufferMemory, sizeof(uint32_t));
-    uint64_t cgen_var_110;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_110, 1);
-    stream->write((uint64_t*)&cgen_var_110, 1 * 8);
-    uint64_t cgen_var_111;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_111, 1);
-    stream->write((uint64_t*)&cgen_var_111, 1 * 8);
-    uint64_t cgen_var_112;
-    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_112, 1);
-    stream->write((uint64_t*)&cgen_var_112, 1 * 8);
+    uint64_t cgen_var_118;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_118, 1);
+    stream->write((uint64_t*)&cgen_var_118, 1 * 8);
+    uint64_t cgen_var_119;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_119, 1);
+    stream->write((uint64_t*)&cgen_var_119, 1 * 8);
+    uint64_t cgen_var_120;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_120, 1);
+    stream->write((uint64_t*)&cgen_var_120, 1 * 8);
     stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
     VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
     stream->read(&vkBindBufferMemory_VkResult_return, sizeof(VkResult));
@@ -1871,15 +1970,15 @@
     mImpl->resources()->deviceMemoryTransform_tohost(&local_memory, 1, &local_memoryOffset, 1, nullptr, 0, nullptr, 0, nullptr, 0);
     countingStream->rewind();
     {
-        uint64_t cgen_var_113;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_113, 1);
-        countingStream->write((uint64_t*)&cgen_var_113, 1 * 8);
-        uint64_t cgen_var_114;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_114, 1);
-        countingStream->write((uint64_t*)&cgen_var_114, 1 * 8);
-        uint64_t cgen_var_115;
-        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_115, 1);
-        countingStream->write((uint64_t*)&cgen_var_115, 1 * 8);
+        uint64_t cgen_var_121;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_121, 1);
+        countingStream->write((uint64_t*)&cgen_var_121, 1 * 8);
+        uint64_t cgen_var_122;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_122, 1);
+        countingStream->write((uint64_t*)&cgen_var_122, 1 * 8);
+        uint64_t cgen_var_123;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_123, 1);
+        countingStream->write((uint64_t*)&cgen_var_123, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
     }
     uint32_t packetSize_vkBindImageMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -1887,15 +1986,15 @@
     uint32_t opcode_vkBindImageMemory = OP_vkBindImageMemory;
     stream->write(&opcode_vkBindImageMemory, sizeof(uint32_t));
     stream->write(&packetSize_vkBindImageMemory, sizeof(uint32_t));
-    uint64_t cgen_var_116;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_116, 1);
-    stream->write((uint64_t*)&cgen_var_116, 1 * 8);
-    uint64_t cgen_var_117;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_117, 1);
-    stream->write((uint64_t*)&cgen_var_117, 1 * 8);
-    uint64_t cgen_var_118;
-    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_118, 1);
-    stream->write((uint64_t*)&cgen_var_118, 1 * 8);
+    uint64_t cgen_var_124;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_124, 1);
+    stream->write((uint64_t*)&cgen_var_124, 1 * 8);
+    uint64_t cgen_var_125;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_125, 1);
+    stream->write((uint64_t*)&cgen_var_125, 1 * 8);
+    uint64_t cgen_var_126;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_126, 1);
+    stream->write((uint64_t*)&cgen_var_126, 1 * 8);
     stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
     VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
     stream->read(&vkBindImageMemory_VkResult_return, sizeof(VkResult));
@@ -1923,12 +2022,12 @@
     local_buffer = buffer;
     countingStream->rewind();
     {
-        uint64_t cgen_var_119;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_119, 1);
-        countingStream->write((uint64_t*)&cgen_var_119, 1 * 8);
-        uint64_t cgen_var_120;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_120, 1);
-        countingStream->write((uint64_t*)&cgen_var_120, 1 * 8);
+        uint64_t cgen_var_127;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_127, 1);
+        countingStream->write((uint64_t*)&cgen_var_127, 1 * 8);
+        uint64_t cgen_var_128;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_128, 1);
+        countingStream->write((uint64_t*)&cgen_var_128, 1 * 8);
         marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
     }
     uint32_t packetSize_vkGetBufferMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -1936,12 +2035,12 @@
     uint32_t opcode_vkGetBufferMemoryRequirements = OP_vkGetBufferMemoryRequirements;
     stream->write(&opcode_vkGetBufferMemoryRequirements, sizeof(uint32_t));
     stream->write(&packetSize_vkGetBufferMemoryRequirements, sizeof(uint32_t));
-    uint64_t cgen_var_121;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_121, 1);
-    stream->write((uint64_t*)&cgen_var_121, 1 * 8);
-    uint64_t cgen_var_122;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_122, 1);
-    stream->write((uint64_t*)&cgen_var_122, 1 * 8);
+    uint64_t cgen_var_129;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_129, 1);
+    stream->write((uint64_t*)&cgen_var_129, 1 * 8);
+    uint64_t cgen_var_130;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_130, 1);
+    stream->write((uint64_t*)&cgen_var_130, 1 * 8);
     marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
     unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
     if (pMemoryRequirements)
@@ -1968,12 +2067,12 @@
     local_image = image;
     countingStream->rewind();
     {
-        uint64_t cgen_var_123;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_123, 1);
-        countingStream->write((uint64_t*)&cgen_var_123, 1 * 8);
-        uint64_t cgen_var_124;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_124, 1);
-        countingStream->write((uint64_t*)&cgen_var_124, 1 * 8);
+        uint64_t cgen_var_131;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_131, 1);
+        countingStream->write((uint64_t*)&cgen_var_131, 1 * 8);
+        uint64_t cgen_var_132;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_132, 1);
+        countingStream->write((uint64_t*)&cgen_var_132, 1 * 8);
         marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
     }
     uint32_t packetSize_vkGetImageMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -1981,12 +2080,12 @@
     uint32_t opcode_vkGetImageMemoryRequirements = OP_vkGetImageMemoryRequirements;
     stream->write(&opcode_vkGetImageMemoryRequirements, sizeof(uint32_t));
     stream->write(&packetSize_vkGetImageMemoryRequirements, sizeof(uint32_t));
-    uint64_t cgen_var_125;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_125, 1);
-    stream->write((uint64_t*)&cgen_var_125, 1 * 8);
-    uint64_t cgen_var_126;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_126, 1);
-    stream->write((uint64_t*)&cgen_var_126, 1 * 8);
+    uint64_t cgen_var_133;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_133, 1);
+    stream->write((uint64_t*)&cgen_var_133, 1 * 8);
+    uint64_t cgen_var_134;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_134, 1);
+    stream->write((uint64_t*)&cgen_var_134, 1 * 8);
     marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
     unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
     if (pMemoryRequirements)
@@ -2014,22 +2113,22 @@
     local_image = image;
     countingStream->rewind();
     {
-        uint64_t cgen_var_127;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_127, 1);
-        countingStream->write((uint64_t*)&cgen_var_127, 1 * 8);
-        uint64_t cgen_var_128;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_128, 1);
-        countingStream->write((uint64_t*)&cgen_var_128, 1 * 8);
+        uint64_t cgen_var_135;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_135, 1);
+        countingStream->write((uint64_t*)&cgen_var_135, 1 * 8);
+        uint64_t cgen_var_136;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_136, 1);
+        countingStream->write((uint64_t*)&cgen_var_136, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_129 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
-        countingStream->putBe64(cgen_var_129);
+        uint64_t cgen_var_137 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+        countingStream->putBe64(cgen_var_137);
         if (pSparseMemoryRequirementCount)
         {
             countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_130 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
-        countingStream->putBe64(cgen_var_130);
+        uint64_t cgen_var_138 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+        countingStream->putBe64(cgen_var_138);
         if (pSparseMemoryRequirements)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -2043,22 +2142,22 @@
     uint32_t opcode_vkGetImageSparseMemoryRequirements = OP_vkGetImageSparseMemoryRequirements;
     stream->write(&opcode_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
     stream->write(&packetSize_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
-    uint64_t cgen_var_131;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_131, 1);
-    stream->write((uint64_t*)&cgen_var_131, 1 * 8);
-    uint64_t cgen_var_132;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_132, 1);
-    stream->write((uint64_t*)&cgen_var_132, 1 * 8);
+    uint64_t cgen_var_139;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_139, 1);
+    stream->write((uint64_t*)&cgen_var_139, 1 * 8);
+    uint64_t cgen_var_140;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_140, 1);
+    stream->write((uint64_t*)&cgen_var_140, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_133 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
-    stream->putBe64(cgen_var_133);
+    uint64_t cgen_var_141 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+    stream->putBe64(cgen_var_141);
     if (pSparseMemoryRequirementCount)
     {
         stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_134 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
-    stream->putBe64(cgen_var_134);
+    uint64_t cgen_var_142 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+    stream->putBe64(cgen_var_142);
     if (pSparseMemoryRequirements)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -2131,24 +2230,24 @@
     local_tiling = tiling;
     countingStream->rewind();
     {
-        uint64_t cgen_var_137;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_137, 1);
-        countingStream->write((uint64_t*)&cgen_var_137, 1 * 8);
+        uint64_t cgen_var_145;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_145, 1);
+        countingStream->write((uint64_t*)&cgen_var_145, 1 * 8);
         countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
         countingStream->write((VkImageType*)&local_type, sizeof(VkImageType));
         countingStream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
         countingStream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
         countingStream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
         // WARNING PTR CHECK
-        uint64_t cgen_var_138 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_138);
+        uint64_t cgen_var_146 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_146);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_139 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_139);
+        uint64_t cgen_var_147 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_147);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -2162,24 +2261,24 @@
     uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties = OP_vkGetPhysicalDeviceSparseImageFormatProperties;
     stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
-    uint64_t cgen_var_140;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_140, 1);
-    stream->write((uint64_t*)&cgen_var_140, 1 * 8);
+    uint64_t cgen_var_148;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_148, 1);
+    stream->write((uint64_t*)&cgen_var_148, 1 * 8);
     stream->write((VkFormat*)&local_format, sizeof(VkFormat));
     stream->write((VkImageType*)&local_type, sizeof(VkImageType));
     stream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
     stream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
     stream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
     // WARNING PTR CHECK
-    uint64_t cgen_var_141 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_141);
+    uint64_t cgen_var_149 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_149);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_142 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_142);
+    uint64_t cgen_var_150 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_150);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -2259,34 +2358,34 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_145;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_145, 1);
-        countingStream->write((uint64_t*)&cgen_var_145, 1 * 8);
+        uint64_t cgen_var_153;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_153, 1);
+        countingStream->write((uint64_t*)&cgen_var_153, 1 * 8);
         countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
         {
             marshal_VkBindSparseInfo(countingStream, (VkBindSparseInfo*)(local_pBindInfo + i));
         }
-        uint64_t cgen_var_146;
-        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_146, 1);
-        countingStream->write((uint64_t*)&cgen_var_146, 1 * 8);
+        uint64_t cgen_var_154;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_154, 1);
+        countingStream->write((uint64_t*)&cgen_var_154, 1 * 8);
     }
     uint32_t packetSize_vkQueueBindSparse = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkQueueBindSparse = OP_vkQueueBindSparse;
     stream->write(&opcode_vkQueueBindSparse, sizeof(uint32_t));
     stream->write(&packetSize_vkQueueBindSparse, sizeof(uint32_t));
-    uint64_t cgen_var_147;
-    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_147, 1);
-    stream->write((uint64_t*)&cgen_var_147, 1 * 8);
+    uint64_t cgen_var_155;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_155, 1);
+    stream->write((uint64_t*)&cgen_var_155, 1 * 8);
     stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
     {
         marshal_VkBindSparseInfo(stream, (VkBindSparseInfo*)(local_pBindInfo + i));
     }
-    uint64_t cgen_var_148;
-    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_148, 1);
-    stream->write((uint64_t*)&cgen_var_148, 1 * 8);
+    uint64_t cgen_var_156;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_156, 1);
+    stream->write((uint64_t*)&cgen_var_156, 1 * 8);
     VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
     stream->read(&vkQueueBindSparse_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -2335,46 +2434,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_149;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_149, 1);
-        countingStream->write((uint64_t*)&cgen_var_149, 1 * 8);
+        uint64_t cgen_var_157;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_157, 1);
+        countingStream->write((uint64_t*)&cgen_var_157, 1 * 8);
         marshal_VkFenceCreateInfo(countingStream, (VkFenceCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_150 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_150);
+        uint64_t cgen_var_158 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_158);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_151;
-        countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_151, 1);
-        countingStream->write((uint64_t*)&cgen_var_151, 8);
+        uint64_t cgen_var_159;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_159, 1);
+        countingStream->write((uint64_t*)&cgen_var_159, 8);
     }
     uint32_t packetSize_vkCreateFence = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateFence = OP_vkCreateFence;
     stream->write(&opcode_vkCreateFence, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateFence, sizeof(uint32_t));
-    uint64_t cgen_var_152;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_152, 1);
-    stream->write((uint64_t*)&cgen_var_152, 1 * 8);
+    uint64_t cgen_var_160;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_160, 1);
+    stream->write((uint64_t*)&cgen_var_160, 1 * 8);
     marshal_VkFenceCreateInfo(stream, (VkFenceCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_153 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_153);
+    uint64_t cgen_var_161 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_161);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_154;
-    stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_154, 1);
-    stream->write((uint64_t*)&cgen_var_154, 8);
+    uint64_t cgen_var_162;
+    stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_162, 1);
+    stream->write((uint64_t*)&cgen_var_162, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_155;
-    stream->read((uint64_t*)&cgen_var_155, 8);
-    stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_155, (VkFence*)pFence, 1);
+    uint64_t cgen_var_163;
+    stream->read((uint64_t*)&cgen_var_163, 8);
+    stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_163, (VkFence*)pFence, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateFence_VkResult_return = (VkResult)0;
     stream->read(&vkCreateFence_VkResult_return, sizeof(VkResult));
@@ -2414,15 +2513,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_156;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_156, 1);
-        countingStream->write((uint64_t*)&cgen_var_156, 1 * 8);
-        uint64_t cgen_var_157;
-        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_157, 1);
-        countingStream->write((uint64_t*)&cgen_var_157, 1 * 8);
+        uint64_t cgen_var_164;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_164, 1);
+        countingStream->write((uint64_t*)&cgen_var_164, 1 * 8);
+        uint64_t cgen_var_165;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_165, 1);
+        countingStream->write((uint64_t*)&cgen_var_165, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_158 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_158);
+        uint64_t cgen_var_166 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_166);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -2433,15 +2532,15 @@
     uint32_t opcode_vkDestroyFence = OP_vkDestroyFence;
     stream->write(&opcode_vkDestroyFence, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyFence, sizeof(uint32_t));
-    uint64_t cgen_var_159;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_159, 1);
-    stream->write((uint64_t*)&cgen_var_159, 1 * 8);
-    uint64_t cgen_var_160;
-    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_160, 1);
-    stream->write((uint64_t*)&cgen_var_160, 1 * 8);
+    uint64_t cgen_var_167;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_167, 1);
+    stream->write((uint64_t*)&cgen_var_167, 1 * 8);
+    uint64_t cgen_var_168;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_168, 1);
+    stream->write((uint64_t*)&cgen_var_168, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_161 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_161);
+    uint64_t cgen_var_169 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_169);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -2473,16 +2572,16 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_162;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_162, 1);
-        countingStream->write((uint64_t*)&cgen_var_162, 1 * 8);
+        uint64_t cgen_var_170;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_170, 1);
+        countingStream->write((uint64_t*)&cgen_var_170, 1 * 8);
         countingStream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
         if (((fenceCount)))
         {
-            uint64_t* cgen_var_163;
-            countingStream->alloc((void**)&cgen_var_163, ((fenceCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_163, ((fenceCount)));
-            countingStream->write((uint64_t*)cgen_var_163, ((fenceCount)) * 8);
+            uint64_t* cgen_var_171;
+            countingStream->alloc((void**)&cgen_var_171, ((fenceCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_171, ((fenceCount)));
+            countingStream->write((uint64_t*)cgen_var_171, ((fenceCount)) * 8);
         }
     }
     uint32_t packetSize_vkResetFences = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -2490,16 +2589,16 @@
     uint32_t opcode_vkResetFences = OP_vkResetFences;
     stream->write(&opcode_vkResetFences, sizeof(uint32_t));
     stream->write(&packetSize_vkResetFences, sizeof(uint32_t));
-    uint64_t cgen_var_164;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_164, 1);
-    stream->write((uint64_t*)&cgen_var_164, 1 * 8);
+    uint64_t cgen_var_172;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_172, 1);
+    stream->write((uint64_t*)&cgen_var_172, 1 * 8);
     stream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
     if (((fenceCount)))
     {
-        uint64_t* cgen_var_165;
-        stream->alloc((void**)&cgen_var_165, ((fenceCount)) * 8);
-        stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_165, ((fenceCount)));
-        stream->write((uint64_t*)cgen_var_165, ((fenceCount)) * 8);
+        uint64_t* cgen_var_173;
+        stream->alloc((void**)&cgen_var_173, ((fenceCount)) * 8);
+        stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_173, ((fenceCount)));
+        stream->write((uint64_t*)cgen_var_173, ((fenceCount)) * 8);
     }
     VkResult vkResetFences_VkResult_return = (VkResult)0;
     stream->read(&vkResetFences_VkResult_return, sizeof(VkResult));
@@ -2526,24 +2625,24 @@
     local_fence = fence;
     countingStream->rewind();
     {
-        uint64_t cgen_var_166;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_166, 1);
-        countingStream->write((uint64_t*)&cgen_var_166, 1 * 8);
-        uint64_t cgen_var_167;
-        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_167, 1);
-        countingStream->write((uint64_t*)&cgen_var_167, 1 * 8);
+        uint64_t cgen_var_174;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_174, 1);
+        countingStream->write((uint64_t*)&cgen_var_174, 1 * 8);
+        uint64_t cgen_var_175;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_175, 1);
+        countingStream->write((uint64_t*)&cgen_var_175, 1 * 8);
     }
     uint32_t packetSize_vkGetFenceStatus = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkGetFenceStatus = OP_vkGetFenceStatus;
     stream->write(&opcode_vkGetFenceStatus, sizeof(uint32_t));
     stream->write(&packetSize_vkGetFenceStatus, sizeof(uint32_t));
-    uint64_t cgen_var_168;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_168, 1);
-    stream->write((uint64_t*)&cgen_var_168, 1 * 8);
-    uint64_t cgen_var_169;
-    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_169, 1);
-    stream->write((uint64_t*)&cgen_var_169, 1 * 8);
+    uint64_t cgen_var_176;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_176, 1);
+    stream->write((uint64_t*)&cgen_var_176, 1 * 8);
+    uint64_t cgen_var_177;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_177, 1);
+    stream->write((uint64_t*)&cgen_var_177, 1 * 8);
     VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
     stream->read(&vkGetFenceStatus_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -2582,16 +2681,16 @@
     local_timeout = timeout;
     countingStream->rewind();
     {
-        uint64_t cgen_var_170;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_170, 1);
-        countingStream->write((uint64_t*)&cgen_var_170, 1 * 8);
+        uint64_t cgen_var_178;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_178, 1);
+        countingStream->write((uint64_t*)&cgen_var_178, 1 * 8);
         countingStream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
         if (((fenceCount)))
         {
-            uint64_t* cgen_var_171;
-            countingStream->alloc((void**)&cgen_var_171, ((fenceCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_171, ((fenceCount)));
-            countingStream->write((uint64_t*)cgen_var_171, ((fenceCount)) * 8);
+            uint64_t* cgen_var_179;
+            countingStream->alloc((void**)&cgen_var_179, ((fenceCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_179, ((fenceCount)));
+            countingStream->write((uint64_t*)cgen_var_179, ((fenceCount)) * 8);
         }
         countingStream->write((VkBool32*)&local_waitAll, sizeof(VkBool32));
         countingStream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
@@ -2601,16 +2700,16 @@
     uint32_t opcode_vkWaitForFences = OP_vkWaitForFences;
     stream->write(&opcode_vkWaitForFences, sizeof(uint32_t));
     stream->write(&packetSize_vkWaitForFences, sizeof(uint32_t));
-    uint64_t cgen_var_172;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_172, 1);
-    stream->write((uint64_t*)&cgen_var_172, 1 * 8);
+    uint64_t cgen_var_180;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_180, 1);
+    stream->write((uint64_t*)&cgen_var_180, 1 * 8);
     stream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
     if (((fenceCount)))
     {
-        uint64_t* cgen_var_173;
-        stream->alloc((void**)&cgen_var_173, ((fenceCount)) * 8);
-        stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_173, ((fenceCount)));
-        stream->write((uint64_t*)cgen_var_173, ((fenceCount)) * 8);
+        uint64_t* cgen_var_181;
+        stream->alloc((void**)&cgen_var_181, ((fenceCount)) * 8);
+        stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_181, ((fenceCount)));
+        stream->write((uint64_t*)cgen_var_181, ((fenceCount)) * 8);
     }
     stream->write((VkBool32*)&local_waitAll, sizeof(VkBool32));
     stream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
@@ -2662,46 +2761,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_174;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_174, 1);
-        countingStream->write((uint64_t*)&cgen_var_174, 1 * 8);
+        uint64_t cgen_var_182;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_182, 1);
+        countingStream->write((uint64_t*)&cgen_var_182, 1 * 8);
         marshal_VkSemaphoreCreateInfo(countingStream, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_175 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_175);
+        uint64_t cgen_var_183 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_183);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_176;
-        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_176, 1);
-        countingStream->write((uint64_t*)&cgen_var_176, 8);
+        uint64_t cgen_var_184;
+        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_184, 1);
+        countingStream->write((uint64_t*)&cgen_var_184, 8);
     }
     uint32_t packetSize_vkCreateSemaphore = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateSemaphore = OP_vkCreateSemaphore;
     stream->write(&opcode_vkCreateSemaphore, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateSemaphore, sizeof(uint32_t));
-    uint64_t cgen_var_177;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_177, 1);
-    stream->write((uint64_t*)&cgen_var_177, 1 * 8);
+    uint64_t cgen_var_185;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_185, 1);
+    stream->write((uint64_t*)&cgen_var_185, 1 * 8);
     marshal_VkSemaphoreCreateInfo(stream, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_178 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_178);
+    uint64_t cgen_var_186 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_186);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_179;
-    stream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_179, 1);
-    stream->write((uint64_t*)&cgen_var_179, 8);
+    uint64_t cgen_var_187;
+    stream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_187, 1);
+    stream->write((uint64_t*)&cgen_var_187, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_180;
-    stream->read((uint64_t*)&cgen_var_180, 8);
-    stream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_180, (VkSemaphore*)pSemaphore, 1);
+    uint64_t cgen_var_188;
+    stream->read((uint64_t*)&cgen_var_188, 8);
+    stream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_188, (VkSemaphore*)pSemaphore, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSemaphore_VkResult_return, sizeof(VkResult));
@@ -2741,15 +2840,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_181;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_181, 1);
-        countingStream->write((uint64_t*)&cgen_var_181, 1 * 8);
-        uint64_t cgen_var_182;
-        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_182, 1);
-        countingStream->write((uint64_t*)&cgen_var_182, 1 * 8);
+        uint64_t cgen_var_189;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_189, 1);
+        countingStream->write((uint64_t*)&cgen_var_189, 1 * 8);
+        uint64_t cgen_var_190;
+        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_190, 1);
+        countingStream->write((uint64_t*)&cgen_var_190, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_183 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_183);
+        uint64_t cgen_var_191 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_191);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -2760,15 +2859,15 @@
     uint32_t opcode_vkDestroySemaphore = OP_vkDestroySemaphore;
     stream->write(&opcode_vkDestroySemaphore, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroySemaphore, sizeof(uint32_t));
-    uint64_t cgen_var_184;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_184, 1);
-    stream->write((uint64_t*)&cgen_var_184, 1 * 8);
-    uint64_t cgen_var_185;
-    stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_185, 1);
-    stream->write((uint64_t*)&cgen_var_185, 1 * 8);
+    uint64_t cgen_var_192;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_192, 1);
+    stream->write((uint64_t*)&cgen_var_192, 1 * 8);
+    uint64_t cgen_var_193;
+    stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_193, 1);
+    stream->write((uint64_t*)&cgen_var_193, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_186 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_186);
+    uint64_t cgen_var_194 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_194);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -2816,46 +2915,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_187;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_187, 1);
-        countingStream->write((uint64_t*)&cgen_var_187, 1 * 8);
+        uint64_t cgen_var_195;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_195, 1);
+        countingStream->write((uint64_t*)&cgen_var_195, 1 * 8);
         marshal_VkEventCreateInfo(countingStream, (VkEventCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_188 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_188);
+        uint64_t cgen_var_196 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_196);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_189;
-        countingStream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_189, 1);
-        countingStream->write((uint64_t*)&cgen_var_189, 8);
+        uint64_t cgen_var_197;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_197, 1);
+        countingStream->write((uint64_t*)&cgen_var_197, 8);
     }
     uint32_t packetSize_vkCreateEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateEvent = OP_vkCreateEvent;
     stream->write(&opcode_vkCreateEvent, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateEvent, sizeof(uint32_t));
-    uint64_t cgen_var_190;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_190, 1);
-    stream->write((uint64_t*)&cgen_var_190, 1 * 8);
+    uint64_t cgen_var_198;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_198, 1);
+    stream->write((uint64_t*)&cgen_var_198, 1 * 8);
     marshal_VkEventCreateInfo(stream, (VkEventCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_191 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_191);
+    uint64_t cgen_var_199 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_199);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_192;
-    stream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_192, 1);
-    stream->write((uint64_t*)&cgen_var_192, 8);
+    uint64_t cgen_var_200;
+    stream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_200, 1);
+    stream->write((uint64_t*)&cgen_var_200, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_193;
-    stream->read((uint64_t*)&cgen_var_193, 8);
-    stream->handleMapping()->mapHandles_u64_VkEvent(&cgen_var_193, (VkEvent*)pEvent, 1);
+    uint64_t cgen_var_201;
+    stream->read((uint64_t*)&cgen_var_201, 8);
+    stream->handleMapping()->mapHandles_u64_VkEvent(&cgen_var_201, (VkEvent*)pEvent, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateEvent_VkResult_return = (VkResult)0;
     stream->read(&vkCreateEvent_VkResult_return, sizeof(VkResult));
@@ -2895,15 +2994,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_194;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_194, 1);
-        countingStream->write((uint64_t*)&cgen_var_194, 1 * 8);
-        uint64_t cgen_var_195;
-        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_195, 1);
-        countingStream->write((uint64_t*)&cgen_var_195, 1 * 8);
+        uint64_t cgen_var_202;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_202, 1);
+        countingStream->write((uint64_t*)&cgen_var_202, 1 * 8);
+        uint64_t cgen_var_203;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_203, 1);
+        countingStream->write((uint64_t*)&cgen_var_203, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_196 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_196);
+        uint64_t cgen_var_204 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_204);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -2914,15 +3013,15 @@
     uint32_t opcode_vkDestroyEvent = OP_vkDestroyEvent;
     stream->write(&opcode_vkDestroyEvent, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyEvent, sizeof(uint32_t));
-    uint64_t cgen_var_197;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_197, 1);
-    stream->write((uint64_t*)&cgen_var_197, 1 * 8);
-    uint64_t cgen_var_198;
-    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_198, 1);
-    stream->write((uint64_t*)&cgen_var_198, 1 * 8);
+    uint64_t cgen_var_205;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_205, 1);
+    stream->write((uint64_t*)&cgen_var_205, 1 * 8);
+    uint64_t cgen_var_206;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_206, 1);
+    stream->write((uint64_t*)&cgen_var_206, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_199 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_199);
+    uint64_t cgen_var_207 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_207);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -2947,24 +3046,24 @@
     local_event = event;
     countingStream->rewind();
     {
-        uint64_t cgen_var_200;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_200, 1);
-        countingStream->write((uint64_t*)&cgen_var_200, 1 * 8);
-        uint64_t cgen_var_201;
-        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_201, 1);
-        countingStream->write((uint64_t*)&cgen_var_201, 1 * 8);
+        uint64_t cgen_var_208;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_208, 1);
+        countingStream->write((uint64_t*)&cgen_var_208, 1 * 8);
+        uint64_t cgen_var_209;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_209, 1);
+        countingStream->write((uint64_t*)&cgen_var_209, 1 * 8);
     }
     uint32_t packetSize_vkGetEventStatus = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkGetEventStatus = OP_vkGetEventStatus;
     stream->write(&opcode_vkGetEventStatus, sizeof(uint32_t));
     stream->write(&packetSize_vkGetEventStatus, sizeof(uint32_t));
-    uint64_t cgen_var_202;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_202, 1);
-    stream->write((uint64_t*)&cgen_var_202, 1 * 8);
-    uint64_t cgen_var_203;
-    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_203, 1);
-    stream->write((uint64_t*)&cgen_var_203, 1 * 8);
+    uint64_t cgen_var_210;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_210, 1);
+    stream->write((uint64_t*)&cgen_var_210, 1 * 8);
+    uint64_t cgen_var_211;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_211, 1);
+    stream->write((uint64_t*)&cgen_var_211, 1 * 8);
     VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
     stream->read(&vkGetEventStatus_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -2990,24 +3089,24 @@
     local_event = event;
     countingStream->rewind();
     {
-        uint64_t cgen_var_204;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_204, 1);
-        countingStream->write((uint64_t*)&cgen_var_204, 1 * 8);
-        uint64_t cgen_var_205;
-        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_205, 1);
-        countingStream->write((uint64_t*)&cgen_var_205, 1 * 8);
+        uint64_t cgen_var_212;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_212, 1);
+        countingStream->write((uint64_t*)&cgen_var_212, 1 * 8);
+        uint64_t cgen_var_213;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_213, 1);
+        countingStream->write((uint64_t*)&cgen_var_213, 1 * 8);
     }
     uint32_t packetSize_vkSetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkSetEvent = OP_vkSetEvent;
     stream->write(&opcode_vkSetEvent, sizeof(uint32_t));
     stream->write(&packetSize_vkSetEvent, sizeof(uint32_t));
-    uint64_t cgen_var_206;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_206, 1);
-    stream->write((uint64_t*)&cgen_var_206, 1 * 8);
-    uint64_t cgen_var_207;
-    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_207, 1);
-    stream->write((uint64_t*)&cgen_var_207, 1 * 8);
+    uint64_t cgen_var_214;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_214, 1);
+    stream->write((uint64_t*)&cgen_var_214, 1 * 8);
+    uint64_t cgen_var_215;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_215, 1);
+    stream->write((uint64_t*)&cgen_var_215, 1 * 8);
     VkResult vkSetEvent_VkResult_return = (VkResult)0;
     stream->read(&vkSetEvent_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -3033,24 +3132,24 @@
     local_event = event;
     countingStream->rewind();
     {
-        uint64_t cgen_var_208;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_208, 1);
-        countingStream->write((uint64_t*)&cgen_var_208, 1 * 8);
-        uint64_t cgen_var_209;
-        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_209, 1);
-        countingStream->write((uint64_t*)&cgen_var_209, 1 * 8);
+        uint64_t cgen_var_216;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_216, 1);
+        countingStream->write((uint64_t*)&cgen_var_216, 1 * 8);
+        uint64_t cgen_var_217;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_217, 1);
+        countingStream->write((uint64_t*)&cgen_var_217, 1 * 8);
     }
     uint32_t packetSize_vkResetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkResetEvent = OP_vkResetEvent;
     stream->write(&opcode_vkResetEvent, sizeof(uint32_t));
     stream->write(&packetSize_vkResetEvent, sizeof(uint32_t));
-    uint64_t cgen_var_210;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_210, 1);
-    stream->write((uint64_t*)&cgen_var_210, 1 * 8);
-    uint64_t cgen_var_211;
-    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_211, 1);
-    stream->write((uint64_t*)&cgen_var_211, 1 * 8);
+    uint64_t cgen_var_218;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_218, 1);
+    stream->write((uint64_t*)&cgen_var_218, 1 * 8);
+    uint64_t cgen_var_219;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_219, 1);
+    stream->write((uint64_t*)&cgen_var_219, 1 * 8);
     VkResult vkResetEvent_VkResult_return = (VkResult)0;
     stream->read(&vkResetEvent_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -3099,46 +3198,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_212;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_212, 1);
-        countingStream->write((uint64_t*)&cgen_var_212, 1 * 8);
+        uint64_t cgen_var_220;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_220, 1);
+        countingStream->write((uint64_t*)&cgen_var_220, 1 * 8);
         marshal_VkQueryPoolCreateInfo(countingStream, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_213 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_213);
+        uint64_t cgen_var_221 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_221);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_214;
-        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_214, 1);
-        countingStream->write((uint64_t*)&cgen_var_214, 8);
+        uint64_t cgen_var_222;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_222, 1);
+        countingStream->write((uint64_t*)&cgen_var_222, 8);
     }
     uint32_t packetSize_vkCreateQueryPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateQueryPool = OP_vkCreateQueryPool;
     stream->write(&opcode_vkCreateQueryPool, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateQueryPool, sizeof(uint32_t));
-    uint64_t cgen_var_215;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_215, 1);
-    stream->write((uint64_t*)&cgen_var_215, 1 * 8);
+    uint64_t cgen_var_223;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_223, 1);
+    stream->write((uint64_t*)&cgen_var_223, 1 * 8);
     marshal_VkQueryPoolCreateInfo(stream, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_216 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_216);
+    uint64_t cgen_var_224 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_224);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_217;
-    stream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_217, 1);
-    stream->write((uint64_t*)&cgen_var_217, 8);
+    uint64_t cgen_var_225;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_225, 1);
+    stream->write((uint64_t*)&cgen_var_225, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_218;
-    stream->read((uint64_t*)&cgen_var_218, 8);
-    stream->handleMapping()->mapHandles_u64_VkQueryPool(&cgen_var_218, (VkQueryPool*)pQueryPool, 1);
+    uint64_t cgen_var_226;
+    stream->read((uint64_t*)&cgen_var_226, 8);
+    stream->handleMapping()->mapHandles_u64_VkQueryPool(&cgen_var_226, (VkQueryPool*)pQueryPool, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
     stream->read(&vkCreateQueryPool_VkResult_return, sizeof(VkResult));
@@ -3178,15 +3277,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_219;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_219, 1);
-        countingStream->write((uint64_t*)&cgen_var_219, 1 * 8);
-        uint64_t cgen_var_220;
-        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_220, 1);
-        countingStream->write((uint64_t*)&cgen_var_220, 1 * 8);
+        uint64_t cgen_var_227;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_227, 1);
+        countingStream->write((uint64_t*)&cgen_var_227, 1 * 8);
+        uint64_t cgen_var_228;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_228, 1);
+        countingStream->write((uint64_t*)&cgen_var_228, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_221 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_221);
+        uint64_t cgen_var_229 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_229);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3197,15 +3296,15 @@
     uint32_t opcode_vkDestroyQueryPool = OP_vkDestroyQueryPool;
     stream->write(&opcode_vkDestroyQueryPool, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyQueryPool, sizeof(uint32_t));
-    uint64_t cgen_var_222;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_222, 1);
-    stream->write((uint64_t*)&cgen_var_222, 1 * 8);
-    uint64_t cgen_var_223;
-    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_223, 1);
-    stream->write((uint64_t*)&cgen_var_223, 1 * 8);
+    uint64_t cgen_var_230;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_230, 1);
+    stream->write((uint64_t*)&cgen_var_230, 1 * 8);
+    uint64_t cgen_var_231;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_231, 1);
+    stream->write((uint64_t*)&cgen_var_231, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_224 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_224);
+    uint64_t cgen_var_232 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_232);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3246,16 +3345,16 @@
     local_flags = flags;
     countingStream->rewind();
     {
-        uint64_t cgen_var_225;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_225, 1);
-        countingStream->write((uint64_t*)&cgen_var_225, 1 * 8);
-        uint64_t cgen_var_226;
-        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_226, 1);
-        countingStream->write((uint64_t*)&cgen_var_226, 1 * 8);
+        uint64_t cgen_var_233;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_233, 1);
+        countingStream->write((uint64_t*)&cgen_var_233, 1 * 8);
+        uint64_t cgen_var_234;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_234, 1);
+        countingStream->write((uint64_t*)&cgen_var_234, 1 * 8);
         countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
-        uint64_t cgen_var_227 = (uint64_t)local_dataSize;
-        countingStream->putBe64(cgen_var_227);
+        uint64_t cgen_var_235 = (uint64_t)local_dataSize;
+        countingStream->putBe64(cgen_var_235);
         countingStream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
         countingStream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
         countingStream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
@@ -3265,16 +3364,16 @@
     uint32_t opcode_vkGetQueryPoolResults = OP_vkGetQueryPoolResults;
     stream->write(&opcode_vkGetQueryPoolResults, sizeof(uint32_t));
     stream->write(&packetSize_vkGetQueryPoolResults, sizeof(uint32_t));
-    uint64_t cgen_var_228;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_228, 1);
-    stream->write((uint64_t*)&cgen_var_228, 1 * 8);
-    uint64_t cgen_var_229;
-    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_229, 1);
-    stream->write((uint64_t*)&cgen_var_229, 1 * 8);
+    uint64_t cgen_var_236;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_236, 1);
+    stream->write((uint64_t*)&cgen_var_236, 1 * 8);
+    uint64_t cgen_var_237;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_237, 1);
+    stream->write((uint64_t*)&cgen_var_237, 1 * 8);
     stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
     stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
-    uint64_t cgen_var_230 = (uint64_t)local_dataSize;
-    stream->putBe64(cgen_var_230);
+    uint64_t cgen_var_238 = (uint64_t)local_dataSize;
+    stream->putBe64(cgen_var_238);
     stream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
     stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
     stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
@@ -3327,46 +3426,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_231;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_231, 1);
-        countingStream->write((uint64_t*)&cgen_var_231, 1 * 8);
+        uint64_t cgen_var_239;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_239, 1);
+        countingStream->write((uint64_t*)&cgen_var_239, 1 * 8);
         marshal_VkBufferCreateInfo(countingStream, (VkBufferCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_232 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_232);
+        uint64_t cgen_var_240 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_240);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_233;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_233, 1);
-        countingStream->write((uint64_t*)&cgen_var_233, 8);
+        uint64_t cgen_var_241;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_241, 1);
+        countingStream->write((uint64_t*)&cgen_var_241, 8);
     }
     uint32_t packetSize_vkCreateBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateBuffer = OP_vkCreateBuffer;
     stream->write(&opcode_vkCreateBuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateBuffer, sizeof(uint32_t));
-    uint64_t cgen_var_234;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_234, 1);
-    stream->write((uint64_t*)&cgen_var_234, 1 * 8);
+    uint64_t cgen_var_242;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_242, 1);
+    stream->write((uint64_t*)&cgen_var_242, 1 * 8);
     marshal_VkBufferCreateInfo(stream, (VkBufferCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_235 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_235);
+    uint64_t cgen_var_243 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_243);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_236;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_236, 1);
-    stream->write((uint64_t*)&cgen_var_236, 8);
+    uint64_t cgen_var_244;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_244, 1);
+    stream->write((uint64_t*)&cgen_var_244, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_237;
-    stream->read((uint64_t*)&cgen_var_237, 8);
-    stream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_237, (VkBuffer*)pBuffer, 1);
+    uint64_t cgen_var_245;
+    stream->read((uint64_t*)&cgen_var_245, 8);
+    stream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_245, (VkBuffer*)pBuffer, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkCreateBuffer_VkResult_return, sizeof(VkResult));
@@ -3406,15 +3505,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_238;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_238, 1);
-        countingStream->write((uint64_t*)&cgen_var_238, 1 * 8);
-        uint64_t cgen_var_239;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_239, 1);
-        countingStream->write((uint64_t*)&cgen_var_239, 1 * 8);
+        uint64_t cgen_var_246;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_246, 1);
+        countingStream->write((uint64_t*)&cgen_var_246, 1 * 8);
+        uint64_t cgen_var_247;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_247, 1);
+        countingStream->write((uint64_t*)&cgen_var_247, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_240 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_240);
+        uint64_t cgen_var_248 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_248);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3425,15 +3524,15 @@
     uint32_t opcode_vkDestroyBuffer = OP_vkDestroyBuffer;
     stream->write(&opcode_vkDestroyBuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyBuffer, sizeof(uint32_t));
-    uint64_t cgen_var_241;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_241, 1);
-    stream->write((uint64_t*)&cgen_var_241, 1 * 8);
-    uint64_t cgen_var_242;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_242, 1);
-    stream->write((uint64_t*)&cgen_var_242, 1 * 8);
+    uint64_t cgen_var_249;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_249, 1);
+    stream->write((uint64_t*)&cgen_var_249, 1 * 8);
+    uint64_t cgen_var_250;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_250, 1);
+    stream->write((uint64_t*)&cgen_var_250, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_243 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_243);
+    uint64_t cgen_var_251 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_251);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3481,46 +3580,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_244;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_244, 1);
-        countingStream->write((uint64_t*)&cgen_var_244, 1 * 8);
+        uint64_t cgen_var_252;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_252, 1);
+        countingStream->write((uint64_t*)&cgen_var_252, 1 * 8);
         marshal_VkBufferViewCreateInfo(countingStream, (VkBufferViewCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_245 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_245);
+        uint64_t cgen_var_253 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_253);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_246;
-        countingStream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_246, 1);
-        countingStream->write((uint64_t*)&cgen_var_246, 8);
+        uint64_t cgen_var_254;
+        countingStream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_254, 1);
+        countingStream->write((uint64_t*)&cgen_var_254, 8);
     }
     uint32_t packetSize_vkCreateBufferView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateBufferView = OP_vkCreateBufferView;
     stream->write(&opcode_vkCreateBufferView, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateBufferView, sizeof(uint32_t));
-    uint64_t cgen_var_247;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_247, 1);
-    stream->write((uint64_t*)&cgen_var_247, 1 * 8);
+    uint64_t cgen_var_255;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_255, 1);
+    stream->write((uint64_t*)&cgen_var_255, 1 * 8);
     marshal_VkBufferViewCreateInfo(stream, (VkBufferViewCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_248 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_248);
+    uint64_t cgen_var_256 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_256);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_249;
-    stream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_249, 1);
-    stream->write((uint64_t*)&cgen_var_249, 8);
+    uint64_t cgen_var_257;
+    stream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_257, 1);
+    stream->write((uint64_t*)&cgen_var_257, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_250;
-    stream->read((uint64_t*)&cgen_var_250, 8);
-    stream->handleMapping()->mapHandles_u64_VkBufferView(&cgen_var_250, (VkBufferView*)pView, 1);
+    uint64_t cgen_var_258;
+    stream->read((uint64_t*)&cgen_var_258, 8);
+    stream->handleMapping()->mapHandles_u64_VkBufferView(&cgen_var_258, (VkBufferView*)pView, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
     stream->read(&vkCreateBufferView_VkResult_return, sizeof(VkResult));
@@ -3560,15 +3659,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_251;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_251, 1);
-        countingStream->write((uint64_t*)&cgen_var_251, 1 * 8);
-        uint64_t cgen_var_252;
-        countingStream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_252, 1);
-        countingStream->write((uint64_t*)&cgen_var_252, 1 * 8);
+        uint64_t cgen_var_259;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_259, 1);
+        countingStream->write((uint64_t*)&cgen_var_259, 1 * 8);
+        uint64_t cgen_var_260;
+        countingStream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_260, 1);
+        countingStream->write((uint64_t*)&cgen_var_260, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_253 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_253);
+        uint64_t cgen_var_261 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_261);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3579,15 +3678,15 @@
     uint32_t opcode_vkDestroyBufferView = OP_vkDestroyBufferView;
     stream->write(&opcode_vkDestroyBufferView, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyBufferView, sizeof(uint32_t));
-    uint64_t cgen_var_254;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_254, 1);
-    stream->write((uint64_t*)&cgen_var_254, 1 * 8);
-    uint64_t cgen_var_255;
-    stream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_255, 1);
-    stream->write((uint64_t*)&cgen_var_255, 1 * 8);
+    uint64_t cgen_var_262;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_262, 1);
+    stream->write((uint64_t*)&cgen_var_262, 1 * 8);
+    uint64_t cgen_var_263;
+    stream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_263, 1);
+    stream->write((uint64_t*)&cgen_var_263, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_256 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_256);
+    uint64_t cgen_var_264 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_264);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3636,46 +3735,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_257;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_257, 1);
-        countingStream->write((uint64_t*)&cgen_var_257, 1 * 8);
+        uint64_t cgen_var_265;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_265, 1);
+        countingStream->write((uint64_t*)&cgen_var_265, 1 * 8);
         marshal_VkImageCreateInfo(countingStream, (VkImageCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_258 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_258);
+        uint64_t cgen_var_266 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_266);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_259;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_259, 1);
-        countingStream->write((uint64_t*)&cgen_var_259, 8);
+        uint64_t cgen_var_267;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_267, 1);
+        countingStream->write((uint64_t*)&cgen_var_267, 8);
     }
     uint32_t packetSize_vkCreateImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateImage = OP_vkCreateImage;
     stream->write(&opcode_vkCreateImage, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateImage, sizeof(uint32_t));
-    uint64_t cgen_var_260;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_260, 1);
-    stream->write((uint64_t*)&cgen_var_260, 1 * 8);
+    uint64_t cgen_var_268;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_268, 1);
+    stream->write((uint64_t*)&cgen_var_268, 1 * 8);
     marshal_VkImageCreateInfo(stream, (VkImageCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_261 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_261);
+    uint64_t cgen_var_269 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_269);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_262;
-    stream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_262, 1);
-    stream->write((uint64_t*)&cgen_var_262, 8);
+    uint64_t cgen_var_270;
+    stream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_270, 1);
+    stream->write((uint64_t*)&cgen_var_270, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_263;
-    stream->read((uint64_t*)&cgen_var_263, 8);
-    stream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_263, (VkImage*)pImage, 1);
+    uint64_t cgen_var_271;
+    stream->read((uint64_t*)&cgen_var_271, 8);
+    stream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_271, (VkImage*)pImage, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateImage_VkResult_return = (VkResult)0;
     stream->read(&vkCreateImage_VkResult_return, sizeof(VkResult));
@@ -3715,15 +3814,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_264;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_264, 1);
-        countingStream->write((uint64_t*)&cgen_var_264, 1 * 8);
-        uint64_t cgen_var_265;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_265, 1);
-        countingStream->write((uint64_t*)&cgen_var_265, 1 * 8);
+        uint64_t cgen_var_272;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_272, 1);
+        countingStream->write((uint64_t*)&cgen_var_272, 1 * 8);
+        uint64_t cgen_var_273;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_273, 1);
+        countingStream->write((uint64_t*)&cgen_var_273, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_266 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_266);
+        uint64_t cgen_var_274 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_274);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3734,15 +3833,15 @@
     uint32_t opcode_vkDestroyImage = OP_vkDestroyImage;
     stream->write(&opcode_vkDestroyImage, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyImage, sizeof(uint32_t));
-    uint64_t cgen_var_267;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_267, 1);
-    stream->write((uint64_t*)&cgen_var_267, 1 * 8);
-    uint64_t cgen_var_268;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_268, 1);
-    stream->write((uint64_t*)&cgen_var_268, 1 * 8);
+    uint64_t cgen_var_275;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_275, 1);
+    stream->write((uint64_t*)&cgen_var_275, 1 * 8);
+    uint64_t cgen_var_276;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_276, 1);
+    stream->write((uint64_t*)&cgen_var_276, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_269 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_269);
+    uint64_t cgen_var_277 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_277);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3780,12 +3879,12 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_270;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_270, 1);
-        countingStream->write((uint64_t*)&cgen_var_270, 1 * 8);
-        uint64_t cgen_var_271;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_271, 1);
-        countingStream->write((uint64_t*)&cgen_var_271, 1 * 8);
+        uint64_t cgen_var_278;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_278, 1);
+        countingStream->write((uint64_t*)&cgen_var_278, 1 * 8);
+        uint64_t cgen_var_279;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_279, 1);
+        countingStream->write((uint64_t*)&cgen_var_279, 1 * 8);
         marshal_VkImageSubresource(countingStream, (VkImageSubresource*)(local_pSubresource));
         marshal_VkSubresourceLayout(countingStream, (VkSubresourceLayout*)(pLayout));
     }
@@ -3794,12 +3893,12 @@
     uint32_t opcode_vkGetImageSubresourceLayout = OP_vkGetImageSubresourceLayout;
     stream->write(&opcode_vkGetImageSubresourceLayout, sizeof(uint32_t));
     stream->write(&packetSize_vkGetImageSubresourceLayout, sizeof(uint32_t));
-    uint64_t cgen_var_272;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_272, 1);
-    stream->write((uint64_t*)&cgen_var_272, 1 * 8);
-    uint64_t cgen_var_273;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_273, 1);
-    stream->write((uint64_t*)&cgen_var_273, 1 * 8);
+    uint64_t cgen_var_280;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_280, 1);
+    stream->write((uint64_t*)&cgen_var_280, 1 * 8);
+    uint64_t cgen_var_281;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_281, 1);
+    stream->write((uint64_t*)&cgen_var_281, 1 * 8);
     marshal_VkImageSubresource(stream, (VkImageSubresource*)(local_pSubresource));
     marshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout));
     unmarshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout));
@@ -3849,46 +3948,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_274;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_274, 1);
-        countingStream->write((uint64_t*)&cgen_var_274, 1 * 8);
+        uint64_t cgen_var_282;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_282, 1);
+        countingStream->write((uint64_t*)&cgen_var_282, 1 * 8);
         marshal_VkImageViewCreateInfo(countingStream, (VkImageViewCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_275 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_275);
+        uint64_t cgen_var_283 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_283);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_276;
-        countingStream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_276, 1);
-        countingStream->write((uint64_t*)&cgen_var_276, 8);
+        uint64_t cgen_var_284;
+        countingStream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_284, 1);
+        countingStream->write((uint64_t*)&cgen_var_284, 8);
     }
     uint32_t packetSize_vkCreateImageView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateImageView = OP_vkCreateImageView;
     stream->write(&opcode_vkCreateImageView, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateImageView, sizeof(uint32_t));
-    uint64_t cgen_var_277;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_277, 1);
-    stream->write((uint64_t*)&cgen_var_277, 1 * 8);
+    uint64_t cgen_var_285;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_285, 1);
+    stream->write((uint64_t*)&cgen_var_285, 1 * 8);
     marshal_VkImageViewCreateInfo(stream, (VkImageViewCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_278 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_278);
+    uint64_t cgen_var_286 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_286);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_279;
-    stream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_279, 1);
-    stream->write((uint64_t*)&cgen_var_279, 8);
+    uint64_t cgen_var_287;
+    stream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_287, 1);
+    stream->write((uint64_t*)&cgen_var_287, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_280;
-    stream->read((uint64_t*)&cgen_var_280, 8);
-    stream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_280, (VkImageView*)pView, 1);
+    uint64_t cgen_var_288;
+    stream->read((uint64_t*)&cgen_var_288, 8);
+    stream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_288, (VkImageView*)pView, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateImageView_VkResult_return = (VkResult)0;
     stream->read(&vkCreateImageView_VkResult_return, sizeof(VkResult));
@@ -3928,15 +4027,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_281;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_281, 1);
-        countingStream->write((uint64_t*)&cgen_var_281, 1 * 8);
-        uint64_t cgen_var_282;
-        countingStream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_282, 1);
-        countingStream->write((uint64_t*)&cgen_var_282, 1 * 8);
+        uint64_t cgen_var_289;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_289, 1);
+        countingStream->write((uint64_t*)&cgen_var_289, 1 * 8);
+        uint64_t cgen_var_290;
+        countingStream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_290, 1);
+        countingStream->write((uint64_t*)&cgen_var_290, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_283 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_283);
+        uint64_t cgen_var_291 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_291);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3947,15 +4046,15 @@
     uint32_t opcode_vkDestroyImageView = OP_vkDestroyImageView;
     stream->write(&opcode_vkDestroyImageView, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyImageView, sizeof(uint32_t));
-    uint64_t cgen_var_284;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_284, 1);
-    stream->write((uint64_t*)&cgen_var_284, 1 * 8);
-    uint64_t cgen_var_285;
-    stream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_285, 1);
-    stream->write((uint64_t*)&cgen_var_285, 1 * 8);
+    uint64_t cgen_var_292;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_292, 1);
+    stream->write((uint64_t*)&cgen_var_292, 1 * 8);
+    uint64_t cgen_var_293;
+    stream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_293, 1);
+    stream->write((uint64_t*)&cgen_var_293, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_286 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_286);
+    uint64_t cgen_var_294 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_294);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4003,46 +4102,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_287;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_287, 1);
-        countingStream->write((uint64_t*)&cgen_var_287, 1 * 8);
+        uint64_t cgen_var_295;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_295, 1);
+        countingStream->write((uint64_t*)&cgen_var_295, 1 * 8);
         marshal_VkShaderModuleCreateInfo(countingStream, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_288 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_288);
+        uint64_t cgen_var_296 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_296);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_289;
-        countingStream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_289, 1);
-        countingStream->write((uint64_t*)&cgen_var_289, 8);
+        uint64_t cgen_var_297;
+        countingStream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_297, 1);
+        countingStream->write((uint64_t*)&cgen_var_297, 8);
     }
     uint32_t packetSize_vkCreateShaderModule = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateShaderModule = OP_vkCreateShaderModule;
     stream->write(&opcode_vkCreateShaderModule, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateShaderModule, sizeof(uint32_t));
-    uint64_t cgen_var_290;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_290, 1);
-    stream->write((uint64_t*)&cgen_var_290, 1 * 8);
+    uint64_t cgen_var_298;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_298, 1);
+    stream->write((uint64_t*)&cgen_var_298, 1 * 8);
     marshal_VkShaderModuleCreateInfo(stream, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_291 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_291);
+    uint64_t cgen_var_299 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_299);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_292;
-    stream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_292, 1);
-    stream->write((uint64_t*)&cgen_var_292, 8);
+    uint64_t cgen_var_300;
+    stream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_300, 1);
+    stream->write((uint64_t*)&cgen_var_300, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_293;
-    stream->read((uint64_t*)&cgen_var_293, 8);
-    stream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_293, (VkShaderModule*)pShaderModule, 1);
+    uint64_t cgen_var_301;
+    stream->read((uint64_t*)&cgen_var_301, 8);
+    stream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_301, (VkShaderModule*)pShaderModule, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
     stream->read(&vkCreateShaderModule_VkResult_return, sizeof(VkResult));
@@ -4082,15 +4181,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_294;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_294, 1);
-        countingStream->write((uint64_t*)&cgen_var_294, 1 * 8);
-        uint64_t cgen_var_295;
-        countingStream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_295, 1);
-        countingStream->write((uint64_t*)&cgen_var_295, 1 * 8);
+        uint64_t cgen_var_302;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_302, 1);
+        countingStream->write((uint64_t*)&cgen_var_302, 1 * 8);
+        uint64_t cgen_var_303;
+        countingStream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_303, 1);
+        countingStream->write((uint64_t*)&cgen_var_303, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_296 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_296);
+        uint64_t cgen_var_304 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_304);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4101,15 +4200,15 @@
     uint32_t opcode_vkDestroyShaderModule = OP_vkDestroyShaderModule;
     stream->write(&opcode_vkDestroyShaderModule, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyShaderModule, sizeof(uint32_t));
-    uint64_t cgen_var_297;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_297, 1);
-    stream->write((uint64_t*)&cgen_var_297, 1 * 8);
-    uint64_t cgen_var_298;
-    stream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_298, 1);
-    stream->write((uint64_t*)&cgen_var_298, 1 * 8);
+    uint64_t cgen_var_305;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_305, 1);
+    stream->write((uint64_t*)&cgen_var_305, 1 * 8);
+    uint64_t cgen_var_306;
+    stream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_306, 1);
+    stream->write((uint64_t*)&cgen_var_306, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_299 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_299);
+    uint64_t cgen_var_307 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_307);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4157,46 +4256,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_300;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_300, 1);
-        countingStream->write((uint64_t*)&cgen_var_300, 1 * 8);
+        uint64_t cgen_var_308;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_308, 1);
+        countingStream->write((uint64_t*)&cgen_var_308, 1 * 8);
         marshal_VkPipelineCacheCreateInfo(countingStream, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_301 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_301);
+        uint64_t cgen_var_309 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_309);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_302;
-        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_302, 1);
-        countingStream->write((uint64_t*)&cgen_var_302, 8);
+        uint64_t cgen_var_310;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_310, 1);
+        countingStream->write((uint64_t*)&cgen_var_310, 8);
     }
     uint32_t packetSize_vkCreatePipelineCache = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreatePipelineCache = OP_vkCreatePipelineCache;
     stream->write(&opcode_vkCreatePipelineCache, sizeof(uint32_t));
     stream->write(&packetSize_vkCreatePipelineCache, sizeof(uint32_t));
-    uint64_t cgen_var_303;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_303, 1);
-    stream->write((uint64_t*)&cgen_var_303, 1 * 8);
+    uint64_t cgen_var_311;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_311, 1);
+    stream->write((uint64_t*)&cgen_var_311, 1 * 8);
     marshal_VkPipelineCacheCreateInfo(stream, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_304 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_304);
+    uint64_t cgen_var_312 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_312);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_305;
-    stream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_305, 1);
-    stream->write((uint64_t*)&cgen_var_305, 8);
+    uint64_t cgen_var_313;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_313, 1);
+    stream->write((uint64_t*)&cgen_var_313, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_306;
-    stream->read((uint64_t*)&cgen_var_306, 8);
-    stream->handleMapping()->mapHandles_u64_VkPipelineCache(&cgen_var_306, (VkPipelineCache*)pPipelineCache, 1);
+    uint64_t cgen_var_314;
+    stream->read((uint64_t*)&cgen_var_314, 8);
+    stream->handleMapping()->mapHandles_u64_VkPipelineCache(&cgen_var_314, (VkPipelineCache*)pPipelineCache, 1);
     stream->unsetHandleMapping();
     VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
     stream->read(&vkCreatePipelineCache_VkResult_return, sizeof(VkResult));
@@ -4236,15 +4335,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_307;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_307, 1);
-        countingStream->write((uint64_t*)&cgen_var_307, 1 * 8);
-        uint64_t cgen_var_308;
-        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_308, 1);
-        countingStream->write((uint64_t*)&cgen_var_308, 1 * 8);
+        uint64_t cgen_var_315;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_315, 1);
+        countingStream->write((uint64_t*)&cgen_var_315, 1 * 8);
+        uint64_t cgen_var_316;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_316, 1);
+        countingStream->write((uint64_t*)&cgen_var_316, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_309 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_309);
+        uint64_t cgen_var_317 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_317);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4255,15 +4354,15 @@
     uint32_t opcode_vkDestroyPipelineCache = OP_vkDestroyPipelineCache;
     stream->write(&opcode_vkDestroyPipelineCache, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyPipelineCache, sizeof(uint32_t));
-    uint64_t cgen_var_310;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_310, 1);
-    stream->write((uint64_t*)&cgen_var_310, 1 * 8);
-    uint64_t cgen_var_311;
-    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_311, 1);
-    stream->write((uint64_t*)&cgen_var_311, 1 * 8);
+    uint64_t cgen_var_318;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_318, 1);
+    stream->write((uint64_t*)&cgen_var_318, 1 * 8);
+    uint64_t cgen_var_319;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_319, 1);
+    stream->write((uint64_t*)&cgen_var_319, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_312 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_312);
+    uint64_t cgen_var_320 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_320);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4290,23 +4389,23 @@
     local_pipelineCache = pipelineCache;
     countingStream->rewind();
     {
-        uint64_t cgen_var_313;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_313, 1);
-        countingStream->write((uint64_t*)&cgen_var_313, 1 * 8);
-        uint64_t cgen_var_314;
-        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_314, 1);
-        countingStream->write((uint64_t*)&cgen_var_314, 1 * 8);
+        uint64_t cgen_var_321;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_321, 1);
+        countingStream->write((uint64_t*)&cgen_var_321, 1 * 8);
+        uint64_t cgen_var_322;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_322, 1);
+        countingStream->write((uint64_t*)&cgen_var_322, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_315 = (uint64_t)(uintptr_t)pDataSize;
-        countingStream->putBe64(cgen_var_315);
+        uint64_t cgen_var_323 = (uint64_t)(uintptr_t)pDataSize;
+        countingStream->putBe64(cgen_var_323);
         if (pDataSize)
         {
-            uint64_t cgen_var_316 = (uint64_t)(*pDataSize);
-            countingStream->putBe64(cgen_var_316);
+            uint64_t cgen_var_324 = (uint64_t)(*pDataSize);
+            countingStream->putBe64(cgen_var_324);
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_317 = (uint64_t)(uintptr_t)pData;
-        countingStream->putBe64(cgen_var_317);
+        uint64_t cgen_var_325 = (uint64_t)(uintptr_t)pData;
+        countingStream->putBe64(cgen_var_325);
         if (pData)
         {
             countingStream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
@@ -4317,23 +4416,23 @@
     uint32_t opcode_vkGetPipelineCacheData = OP_vkGetPipelineCacheData;
     stream->write(&opcode_vkGetPipelineCacheData, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPipelineCacheData, sizeof(uint32_t));
-    uint64_t cgen_var_318;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_318, 1);
-    stream->write((uint64_t*)&cgen_var_318, 1 * 8);
-    uint64_t cgen_var_319;
-    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_319, 1);
-    stream->write((uint64_t*)&cgen_var_319, 1 * 8);
+    uint64_t cgen_var_326;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_326, 1);
+    stream->write((uint64_t*)&cgen_var_326, 1 * 8);
+    uint64_t cgen_var_327;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_327, 1);
+    stream->write((uint64_t*)&cgen_var_327, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_320 = (uint64_t)(uintptr_t)pDataSize;
-    stream->putBe64(cgen_var_320);
+    uint64_t cgen_var_328 = (uint64_t)(uintptr_t)pDataSize;
+    stream->putBe64(cgen_var_328);
     if (pDataSize)
     {
-        uint64_t cgen_var_321 = (uint64_t)(*pDataSize);
-        stream->putBe64(cgen_var_321);
+        uint64_t cgen_var_329 = (uint64_t)(*pDataSize);
+        stream->putBe64(cgen_var_329);
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_322 = (uint64_t)(uintptr_t)pData;
-    stream->putBe64(cgen_var_322);
+    uint64_t cgen_var_330 = (uint64_t)(uintptr_t)pData;
+    stream->putBe64(cgen_var_330);
     if (pData)
     {
         stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
@@ -4395,19 +4494,19 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_326;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_326, 1);
-        countingStream->write((uint64_t*)&cgen_var_326, 1 * 8);
-        uint64_t cgen_var_327;
-        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_327, 1);
-        countingStream->write((uint64_t*)&cgen_var_327, 1 * 8);
+        uint64_t cgen_var_334;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_334, 1);
+        countingStream->write((uint64_t*)&cgen_var_334, 1 * 8);
+        uint64_t cgen_var_335;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_335, 1);
+        countingStream->write((uint64_t*)&cgen_var_335, 1 * 8);
         countingStream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
         if (((srcCacheCount)))
         {
-            uint64_t* cgen_var_328;
-            countingStream->alloc((void**)&cgen_var_328, ((srcCacheCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_328, ((srcCacheCount)));
-            countingStream->write((uint64_t*)cgen_var_328, ((srcCacheCount)) * 8);
+            uint64_t* cgen_var_336;
+            countingStream->alloc((void**)&cgen_var_336, ((srcCacheCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_336, ((srcCacheCount)));
+            countingStream->write((uint64_t*)cgen_var_336, ((srcCacheCount)) * 8);
         }
     }
     uint32_t packetSize_vkMergePipelineCaches = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -4415,19 +4514,19 @@
     uint32_t opcode_vkMergePipelineCaches = OP_vkMergePipelineCaches;
     stream->write(&opcode_vkMergePipelineCaches, sizeof(uint32_t));
     stream->write(&packetSize_vkMergePipelineCaches, sizeof(uint32_t));
-    uint64_t cgen_var_329;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_329, 1);
-    stream->write((uint64_t*)&cgen_var_329, 1 * 8);
-    uint64_t cgen_var_330;
-    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_330, 1);
-    stream->write((uint64_t*)&cgen_var_330, 1 * 8);
+    uint64_t cgen_var_337;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_337, 1);
+    stream->write((uint64_t*)&cgen_var_337, 1 * 8);
+    uint64_t cgen_var_338;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_338, 1);
+    stream->write((uint64_t*)&cgen_var_338, 1 * 8);
     stream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
     if (((srcCacheCount)))
     {
-        uint64_t* cgen_var_331;
-        stream->alloc((void**)&cgen_var_331, ((srcCacheCount)) * 8);
-        stream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_331, ((srcCacheCount)));
-        stream->write((uint64_t*)cgen_var_331, ((srcCacheCount)) * 8);
+        uint64_t* cgen_var_339;
+        stream->alloc((void**)&cgen_var_339, ((srcCacheCount)) * 8);
+        stream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_339, ((srcCacheCount)));
+        stream->write((uint64_t*)cgen_var_339, ((srcCacheCount)) * 8);
     }
     VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
     stream->read(&vkMergePipelineCaches_VkResult_return, sizeof(VkResult));
@@ -4489,30 +4588,30 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_332;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_332, 1);
-        countingStream->write((uint64_t*)&cgen_var_332, 1 * 8);
-        uint64_t cgen_var_333;
-        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_333, 1);
-        countingStream->write((uint64_t*)&cgen_var_333, 1 * 8);
+        uint64_t cgen_var_340;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_340, 1);
+        countingStream->write((uint64_t*)&cgen_var_340, 1 * 8);
+        uint64_t cgen_var_341;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_341, 1);
+        countingStream->write((uint64_t*)&cgen_var_341, 1 * 8);
         countingStream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
         {
             marshal_VkGraphicsPipelineCreateInfo(countingStream, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_334 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_334);
+        uint64_t cgen_var_342 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_342);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
         if (((createInfoCount)))
         {
-            uint64_t* cgen_var_335;
-            countingStream->alloc((void**)&cgen_var_335, ((createInfoCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_335, ((createInfoCount)));
-            countingStream->write((uint64_t*)cgen_var_335, ((createInfoCount)) * 8);
+            uint64_t* cgen_var_343;
+            countingStream->alloc((void**)&cgen_var_343, ((createInfoCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_343, ((createInfoCount)));
+            countingStream->write((uint64_t*)cgen_var_343, ((createInfoCount)) * 8);
         }
     }
     uint32_t packetSize_vkCreateGraphicsPipelines = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -4520,20 +4619,20 @@
     uint32_t opcode_vkCreateGraphicsPipelines = OP_vkCreateGraphicsPipelines;
     stream->write(&opcode_vkCreateGraphicsPipelines, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateGraphicsPipelines, sizeof(uint32_t));
-    uint64_t cgen_var_336;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_336, 1);
-    stream->write((uint64_t*)&cgen_var_336, 1 * 8);
-    uint64_t cgen_var_337;
-    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_337, 1);
-    stream->write((uint64_t*)&cgen_var_337, 1 * 8);
+    uint64_t cgen_var_344;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_344, 1);
+    stream->write((uint64_t*)&cgen_var_344, 1 * 8);
+    uint64_t cgen_var_345;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_345, 1);
+    stream->write((uint64_t*)&cgen_var_345, 1 * 8);
     stream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
     {
         marshal_VkGraphicsPipelineCreateInfo(stream, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_338 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_338);
+    uint64_t cgen_var_346 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_346);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4541,19 +4640,19 @@
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
     if (((createInfoCount)))
     {
-        uint64_t* cgen_var_339;
-        stream->alloc((void**)&cgen_var_339, ((createInfoCount)) * 8);
-        stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_339, ((createInfoCount)));
-        stream->write((uint64_t*)cgen_var_339, ((createInfoCount)) * 8);
+        uint64_t* cgen_var_347;
+        stream->alloc((void**)&cgen_var_347, ((createInfoCount)) * 8);
+        stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_347, ((createInfoCount)));
+        stream->write((uint64_t*)cgen_var_347, ((createInfoCount)) * 8);
     }
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
     if (((createInfoCount)))
     {
-        uint64_t* cgen_var_340;
-        stream->alloc((void**)&cgen_var_340, ((createInfoCount)) * 8);
-        stream->read((uint64_t*)cgen_var_340, ((createInfoCount)) * 8);
-        stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_340, (VkPipeline*)pPipelines, ((createInfoCount)));
+        uint64_t* cgen_var_348;
+        stream->alloc((void**)&cgen_var_348, ((createInfoCount)) * 8);
+        stream->read((uint64_t*)cgen_var_348, ((createInfoCount)) * 8);
+        stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_348, (VkPipeline*)pPipelines, ((createInfoCount)));
     }
     stream->unsetHandleMapping();
     VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
@@ -4616,30 +4715,30 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_341;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_341, 1);
-        countingStream->write((uint64_t*)&cgen_var_341, 1 * 8);
-        uint64_t cgen_var_342;
-        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_342, 1);
-        countingStream->write((uint64_t*)&cgen_var_342, 1 * 8);
+        uint64_t cgen_var_349;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_349, 1);
+        countingStream->write((uint64_t*)&cgen_var_349, 1 * 8);
+        uint64_t cgen_var_350;
+        countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_350, 1);
+        countingStream->write((uint64_t*)&cgen_var_350, 1 * 8);
         countingStream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
         {
             marshal_VkComputePipelineCreateInfo(countingStream, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_343 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_343);
+        uint64_t cgen_var_351 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_351);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
         if (((createInfoCount)))
         {
-            uint64_t* cgen_var_344;
-            countingStream->alloc((void**)&cgen_var_344, ((createInfoCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_344, ((createInfoCount)));
-            countingStream->write((uint64_t*)cgen_var_344, ((createInfoCount)) * 8);
+            uint64_t* cgen_var_352;
+            countingStream->alloc((void**)&cgen_var_352, ((createInfoCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_352, ((createInfoCount)));
+            countingStream->write((uint64_t*)cgen_var_352, ((createInfoCount)) * 8);
         }
     }
     uint32_t packetSize_vkCreateComputePipelines = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -4647,20 +4746,20 @@
     uint32_t opcode_vkCreateComputePipelines = OP_vkCreateComputePipelines;
     stream->write(&opcode_vkCreateComputePipelines, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateComputePipelines, sizeof(uint32_t));
-    uint64_t cgen_var_345;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_345, 1);
-    stream->write((uint64_t*)&cgen_var_345, 1 * 8);
-    uint64_t cgen_var_346;
-    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_346, 1);
-    stream->write((uint64_t*)&cgen_var_346, 1 * 8);
+    uint64_t cgen_var_353;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_353, 1);
+    stream->write((uint64_t*)&cgen_var_353, 1 * 8);
+    uint64_t cgen_var_354;
+    stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_354, 1);
+    stream->write((uint64_t*)&cgen_var_354, 1 * 8);
     stream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
     {
         marshal_VkComputePipelineCreateInfo(stream, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_347 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_347);
+    uint64_t cgen_var_355 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_355);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4668,19 +4767,19 @@
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
     if (((createInfoCount)))
     {
-        uint64_t* cgen_var_348;
-        stream->alloc((void**)&cgen_var_348, ((createInfoCount)) * 8);
-        stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_348, ((createInfoCount)));
-        stream->write((uint64_t*)cgen_var_348, ((createInfoCount)) * 8);
+        uint64_t* cgen_var_356;
+        stream->alloc((void**)&cgen_var_356, ((createInfoCount)) * 8);
+        stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_356, ((createInfoCount)));
+        stream->write((uint64_t*)cgen_var_356, ((createInfoCount)) * 8);
     }
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
     if (((createInfoCount)))
     {
-        uint64_t* cgen_var_349;
-        stream->alloc((void**)&cgen_var_349, ((createInfoCount)) * 8);
-        stream->read((uint64_t*)cgen_var_349, ((createInfoCount)) * 8);
-        stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_349, (VkPipeline*)pPipelines, ((createInfoCount)));
+        uint64_t* cgen_var_357;
+        stream->alloc((void**)&cgen_var_357, ((createInfoCount)) * 8);
+        stream->read((uint64_t*)cgen_var_357, ((createInfoCount)) * 8);
+        stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_357, (VkPipeline*)pPipelines, ((createInfoCount)));
     }
     stream->unsetHandleMapping();
     VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
@@ -4721,15 +4820,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_350;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_350, 1);
-        countingStream->write((uint64_t*)&cgen_var_350, 1 * 8);
-        uint64_t cgen_var_351;
-        countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_351, 1);
-        countingStream->write((uint64_t*)&cgen_var_351, 1 * 8);
+        uint64_t cgen_var_358;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_358, 1);
+        countingStream->write((uint64_t*)&cgen_var_358, 1 * 8);
+        uint64_t cgen_var_359;
+        countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_359, 1);
+        countingStream->write((uint64_t*)&cgen_var_359, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_352 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_352);
+        uint64_t cgen_var_360 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_360);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4740,15 +4839,15 @@
     uint32_t opcode_vkDestroyPipeline = OP_vkDestroyPipeline;
     stream->write(&opcode_vkDestroyPipeline, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyPipeline, sizeof(uint32_t));
-    uint64_t cgen_var_353;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_353, 1);
-    stream->write((uint64_t*)&cgen_var_353, 1 * 8);
-    uint64_t cgen_var_354;
-    stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_354, 1);
-    stream->write((uint64_t*)&cgen_var_354, 1 * 8);
+    uint64_t cgen_var_361;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_361, 1);
+    stream->write((uint64_t*)&cgen_var_361, 1 * 8);
+    uint64_t cgen_var_362;
+    stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_362, 1);
+    stream->write((uint64_t*)&cgen_var_362, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_355 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_355);
+    uint64_t cgen_var_363 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_363);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4796,46 +4895,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_356;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_356, 1);
-        countingStream->write((uint64_t*)&cgen_var_356, 1 * 8);
+        uint64_t cgen_var_364;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_364, 1);
+        countingStream->write((uint64_t*)&cgen_var_364, 1 * 8);
         marshal_VkPipelineLayoutCreateInfo(countingStream, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_357 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_357);
+        uint64_t cgen_var_365 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_365);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_358;
-        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_358, 1);
-        countingStream->write((uint64_t*)&cgen_var_358, 8);
+        uint64_t cgen_var_366;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_366, 1);
+        countingStream->write((uint64_t*)&cgen_var_366, 8);
     }
     uint32_t packetSize_vkCreatePipelineLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreatePipelineLayout = OP_vkCreatePipelineLayout;
     stream->write(&opcode_vkCreatePipelineLayout, sizeof(uint32_t));
     stream->write(&packetSize_vkCreatePipelineLayout, sizeof(uint32_t));
-    uint64_t cgen_var_359;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_359, 1);
-    stream->write((uint64_t*)&cgen_var_359, 1 * 8);
+    uint64_t cgen_var_367;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_367, 1);
+    stream->write((uint64_t*)&cgen_var_367, 1 * 8);
     marshal_VkPipelineLayoutCreateInfo(stream, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_360 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_360);
+    uint64_t cgen_var_368 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_368);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_361;
-    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_361, 1);
-    stream->write((uint64_t*)&cgen_var_361, 8);
+    uint64_t cgen_var_369;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_369, 1);
+    stream->write((uint64_t*)&cgen_var_369, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_362;
-    stream->read((uint64_t*)&cgen_var_362, 8);
-    stream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_362, (VkPipelineLayout*)pPipelineLayout, 1);
+    uint64_t cgen_var_370;
+    stream->read((uint64_t*)&cgen_var_370, 8);
+    stream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_370, (VkPipelineLayout*)pPipelineLayout, 1);
     stream->unsetHandleMapping();
     VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
     stream->read(&vkCreatePipelineLayout_VkResult_return, sizeof(VkResult));
@@ -4875,15 +4974,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_363;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_363, 1);
-        countingStream->write((uint64_t*)&cgen_var_363, 1 * 8);
-        uint64_t cgen_var_364;
-        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_364, 1);
-        countingStream->write((uint64_t*)&cgen_var_364, 1 * 8);
+        uint64_t cgen_var_371;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_371, 1);
+        countingStream->write((uint64_t*)&cgen_var_371, 1 * 8);
+        uint64_t cgen_var_372;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_372, 1);
+        countingStream->write((uint64_t*)&cgen_var_372, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_365 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_365);
+        uint64_t cgen_var_373 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_373);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4894,15 +4993,15 @@
     uint32_t opcode_vkDestroyPipelineLayout = OP_vkDestroyPipelineLayout;
     stream->write(&opcode_vkDestroyPipelineLayout, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyPipelineLayout, sizeof(uint32_t));
-    uint64_t cgen_var_366;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_366, 1);
-    stream->write((uint64_t*)&cgen_var_366, 1 * 8);
-    uint64_t cgen_var_367;
-    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_367, 1);
-    stream->write((uint64_t*)&cgen_var_367, 1 * 8);
+    uint64_t cgen_var_374;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_374, 1);
+    stream->write((uint64_t*)&cgen_var_374, 1 * 8);
+    uint64_t cgen_var_375;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_375, 1);
+    stream->write((uint64_t*)&cgen_var_375, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_368 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_368);
+    uint64_t cgen_var_376 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_376);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4950,46 +5049,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_369;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_369, 1);
-        countingStream->write((uint64_t*)&cgen_var_369, 1 * 8);
+        uint64_t cgen_var_377;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_377, 1);
+        countingStream->write((uint64_t*)&cgen_var_377, 1 * 8);
         marshal_VkSamplerCreateInfo(countingStream, (VkSamplerCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_370 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_370);
+        uint64_t cgen_var_378 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_378);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_371;
-        countingStream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_371, 1);
-        countingStream->write((uint64_t*)&cgen_var_371, 8);
+        uint64_t cgen_var_379;
+        countingStream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_379, 1);
+        countingStream->write((uint64_t*)&cgen_var_379, 8);
     }
     uint32_t packetSize_vkCreateSampler = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateSampler = OP_vkCreateSampler;
     stream->write(&opcode_vkCreateSampler, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateSampler, sizeof(uint32_t));
-    uint64_t cgen_var_372;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_372, 1);
-    stream->write((uint64_t*)&cgen_var_372, 1 * 8);
+    uint64_t cgen_var_380;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_380, 1);
+    stream->write((uint64_t*)&cgen_var_380, 1 * 8);
     marshal_VkSamplerCreateInfo(stream, (VkSamplerCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_373 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_373);
+    uint64_t cgen_var_381 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_381);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_374;
-    stream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_374, 1);
-    stream->write((uint64_t*)&cgen_var_374, 8);
+    uint64_t cgen_var_382;
+    stream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_382, 1);
+    stream->write((uint64_t*)&cgen_var_382, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_375;
-    stream->read((uint64_t*)&cgen_var_375, 8);
-    stream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_375, (VkSampler*)pSampler, 1);
+    uint64_t cgen_var_383;
+    stream->read((uint64_t*)&cgen_var_383, 8);
+    stream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_383, (VkSampler*)pSampler, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateSampler_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSampler_VkResult_return, sizeof(VkResult));
@@ -5029,15 +5128,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_376;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_376, 1);
-        countingStream->write((uint64_t*)&cgen_var_376, 1 * 8);
-        uint64_t cgen_var_377;
-        countingStream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_377, 1);
-        countingStream->write((uint64_t*)&cgen_var_377, 1 * 8);
+        uint64_t cgen_var_384;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_384, 1);
+        countingStream->write((uint64_t*)&cgen_var_384, 1 * 8);
+        uint64_t cgen_var_385;
+        countingStream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_385, 1);
+        countingStream->write((uint64_t*)&cgen_var_385, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_378 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_378);
+        uint64_t cgen_var_386 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_386);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5048,15 +5147,15 @@
     uint32_t opcode_vkDestroySampler = OP_vkDestroySampler;
     stream->write(&opcode_vkDestroySampler, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroySampler, sizeof(uint32_t));
-    uint64_t cgen_var_379;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_379, 1);
-    stream->write((uint64_t*)&cgen_var_379, 1 * 8);
-    uint64_t cgen_var_380;
-    stream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_380, 1);
-    stream->write((uint64_t*)&cgen_var_380, 1 * 8);
+    uint64_t cgen_var_387;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_387, 1);
+    stream->write((uint64_t*)&cgen_var_387, 1 * 8);
+    uint64_t cgen_var_388;
+    stream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_388, 1);
+    stream->write((uint64_t*)&cgen_var_388, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_381 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_381);
+    uint64_t cgen_var_389 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_389);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5104,46 +5203,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_382;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_382, 1);
-        countingStream->write((uint64_t*)&cgen_var_382, 1 * 8);
+        uint64_t cgen_var_390;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_390, 1);
+        countingStream->write((uint64_t*)&cgen_var_390, 1 * 8);
         marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_383 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_383);
+        uint64_t cgen_var_391 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_391);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_384;
-        countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_384, 1);
-        countingStream->write((uint64_t*)&cgen_var_384, 8);
+        uint64_t cgen_var_392;
+        countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_392, 1);
+        countingStream->write((uint64_t*)&cgen_var_392, 8);
     }
     uint32_t packetSize_vkCreateDescriptorSetLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateDescriptorSetLayout = OP_vkCreateDescriptorSetLayout;
     stream->write(&opcode_vkCreateDescriptorSetLayout, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateDescriptorSetLayout, sizeof(uint32_t));
-    uint64_t cgen_var_385;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_385, 1);
-    stream->write((uint64_t*)&cgen_var_385, 1 * 8);
+    uint64_t cgen_var_393;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_393, 1);
+    stream->write((uint64_t*)&cgen_var_393, 1 * 8);
     marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_386 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_386);
+    uint64_t cgen_var_394 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_394);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_387;
-    stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_387, 1);
-    stream->write((uint64_t*)&cgen_var_387, 8);
+    uint64_t cgen_var_395;
+    stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_395, 1);
+    stream->write((uint64_t*)&cgen_var_395, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_388;
-    stream->read((uint64_t*)&cgen_var_388, 8);
-    stream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_388, (VkDescriptorSetLayout*)pSetLayout, 1);
+    uint64_t cgen_var_396;
+    stream->read((uint64_t*)&cgen_var_396, 8);
+    stream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_396, (VkDescriptorSetLayout*)pSetLayout, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorSetLayout_VkResult_return, sizeof(VkResult));
@@ -5183,15 +5282,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_389;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_389, 1);
-        countingStream->write((uint64_t*)&cgen_var_389, 1 * 8);
-        uint64_t cgen_var_390;
-        countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_390, 1);
-        countingStream->write((uint64_t*)&cgen_var_390, 1 * 8);
+        uint64_t cgen_var_397;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_397, 1);
+        countingStream->write((uint64_t*)&cgen_var_397, 1 * 8);
+        uint64_t cgen_var_398;
+        countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_398, 1);
+        countingStream->write((uint64_t*)&cgen_var_398, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_391 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_391);
+        uint64_t cgen_var_399 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_399);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5202,15 +5301,15 @@
     uint32_t opcode_vkDestroyDescriptorSetLayout = OP_vkDestroyDescriptorSetLayout;
     stream->write(&opcode_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
-    uint64_t cgen_var_392;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_392, 1);
-    stream->write((uint64_t*)&cgen_var_392, 1 * 8);
-    uint64_t cgen_var_393;
-    stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_393, 1);
-    stream->write((uint64_t*)&cgen_var_393, 1 * 8);
+    uint64_t cgen_var_400;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_400, 1);
+    stream->write((uint64_t*)&cgen_var_400, 1 * 8);
+    uint64_t cgen_var_401;
+    stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_401, 1);
+    stream->write((uint64_t*)&cgen_var_401, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_394 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_394);
+    uint64_t cgen_var_402 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_402);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5258,46 +5357,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_395;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_395, 1);
-        countingStream->write((uint64_t*)&cgen_var_395, 1 * 8);
+        uint64_t cgen_var_403;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_403, 1);
+        countingStream->write((uint64_t*)&cgen_var_403, 1 * 8);
         marshal_VkDescriptorPoolCreateInfo(countingStream, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_396 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_396);
+        uint64_t cgen_var_404 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_404);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_397;
-        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_397, 1);
-        countingStream->write((uint64_t*)&cgen_var_397, 8);
+        uint64_t cgen_var_405;
+        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_405, 1);
+        countingStream->write((uint64_t*)&cgen_var_405, 8);
     }
     uint32_t packetSize_vkCreateDescriptorPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateDescriptorPool = OP_vkCreateDescriptorPool;
     stream->write(&opcode_vkCreateDescriptorPool, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateDescriptorPool, sizeof(uint32_t));
-    uint64_t cgen_var_398;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_398, 1);
-    stream->write((uint64_t*)&cgen_var_398, 1 * 8);
+    uint64_t cgen_var_406;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_406, 1);
+    stream->write((uint64_t*)&cgen_var_406, 1 * 8);
     marshal_VkDescriptorPoolCreateInfo(stream, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_399 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_399);
+    uint64_t cgen_var_407 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_407);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_400;
-    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_400, 1);
-    stream->write((uint64_t*)&cgen_var_400, 8);
+    uint64_t cgen_var_408;
+    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_408, 1);
+    stream->write((uint64_t*)&cgen_var_408, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_401;
-    stream->read((uint64_t*)&cgen_var_401, 8);
-    stream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_401, (VkDescriptorPool*)pDescriptorPool, 1);
+    uint64_t cgen_var_409;
+    stream->read((uint64_t*)&cgen_var_409, 8);
+    stream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_409, (VkDescriptorPool*)pDescriptorPool, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorPool_VkResult_return, sizeof(VkResult));
@@ -5337,15 +5436,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_402;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_402, 1);
-        countingStream->write((uint64_t*)&cgen_var_402, 1 * 8);
-        uint64_t cgen_var_403;
-        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_403, 1);
-        countingStream->write((uint64_t*)&cgen_var_403, 1 * 8);
+        uint64_t cgen_var_410;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_410, 1);
+        countingStream->write((uint64_t*)&cgen_var_410, 1 * 8);
+        uint64_t cgen_var_411;
+        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_411, 1);
+        countingStream->write((uint64_t*)&cgen_var_411, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_404 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_404);
+        uint64_t cgen_var_412 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_412);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5356,15 +5455,15 @@
     uint32_t opcode_vkDestroyDescriptorPool = OP_vkDestroyDescriptorPool;
     stream->write(&opcode_vkDestroyDescriptorPool, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyDescriptorPool, sizeof(uint32_t));
-    uint64_t cgen_var_405;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_405, 1);
-    stream->write((uint64_t*)&cgen_var_405, 1 * 8);
-    uint64_t cgen_var_406;
-    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_406, 1);
-    stream->write((uint64_t*)&cgen_var_406, 1 * 8);
+    uint64_t cgen_var_413;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_413, 1);
+    stream->write((uint64_t*)&cgen_var_413, 1 * 8);
+    uint64_t cgen_var_414;
+    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_414, 1);
+    stream->write((uint64_t*)&cgen_var_414, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_407 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_407);
+    uint64_t cgen_var_415 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_415);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5392,12 +5491,12 @@
     local_flags = flags;
     countingStream->rewind();
     {
-        uint64_t cgen_var_408;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_408, 1);
-        countingStream->write((uint64_t*)&cgen_var_408, 1 * 8);
-        uint64_t cgen_var_409;
-        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_409, 1);
-        countingStream->write((uint64_t*)&cgen_var_409, 1 * 8);
+        uint64_t cgen_var_416;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_416, 1);
+        countingStream->write((uint64_t*)&cgen_var_416, 1 * 8);
+        uint64_t cgen_var_417;
+        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_417, 1);
+        countingStream->write((uint64_t*)&cgen_var_417, 1 * 8);
         countingStream->write((VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags));
     }
     uint32_t packetSize_vkResetDescriptorPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -5405,12 +5504,12 @@
     uint32_t opcode_vkResetDescriptorPool = OP_vkResetDescriptorPool;
     stream->write(&opcode_vkResetDescriptorPool, sizeof(uint32_t));
     stream->write(&packetSize_vkResetDescriptorPool, sizeof(uint32_t));
-    uint64_t cgen_var_410;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_410, 1);
-    stream->write((uint64_t*)&cgen_var_410, 1 * 8);
-    uint64_t cgen_var_411;
-    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_411, 1);
-    stream->write((uint64_t*)&cgen_var_411, 1 * 8);
+    uint64_t cgen_var_418;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_418, 1);
+    stream->write((uint64_t*)&cgen_var_418, 1 * 8);
+    uint64_t cgen_var_419;
+    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_419, 1);
+    stream->write((uint64_t*)&cgen_var_419, 1 * 8);
     stream->write((VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags));
     VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
     stream->read(&vkResetDescriptorPool_VkResult_return, sizeof(VkResult));
@@ -5447,16 +5546,16 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_412;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_412, 1);
-        countingStream->write((uint64_t*)&cgen_var_412, 1 * 8);
+        uint64_t cgen_var_420;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_420, 1);
+        countingStream->write((uint64_t*)&cgen_var_420, 1 * 8);
         marshal_VkDescriptorSetAllocateInfo(countingStream, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
         if (pAllocateInfo->descriptorSetCount)
         {
-            uint64_t* cgen_var_413;
-            countingStream->alloc((void**)&cgen_var_413, pAllocateInfo->descriptorSetCount * 8);
-            countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_413, pAllocateInfo->descriptorSetCount);
-            countingStream->write((uint64_t*)cgen_var_413, pAllocateInfo->descriptorSetCount * 8);
+            uint64_t* cgen_var_421;
+            countingStream->alloc((void**)&cgen_var_421, pAllocateInfo->descriptorSetCount * 8);
+            countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_421, pAllocateInfo->descriptorSetCount);
+            countingStream->write((uint64_t*)cgen_var_421, pAllocateInfo->descriptorSetCount * 8);
         }
     }
     uint32_t packetSize_vkAllocateDescriptorSets = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -5464,26 +5563,26 @@
     uint32_t opcode_vkAllocateDescriptorSets = OP_vkAllocateDescriptorSets;
     stream->write(&opcode_vkAllocateDescriptorSets, sizeof(uint32_t));
     stream->write(&packetSize_vkAllocateDescriptorSets, sizeof(uint32_t));
-    uint64_t cgen_var_414;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_414, 1);
-    stream->write((uint64_t*)&cgen_var_414, 1 * 8);
+    uint64_t cgen_var_422;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_422, 1);
+    stream->write((uint64_t*)&cgen_var_422, 1 * 8);
     marshal_VkDescriptorSetAllocateInfo(stream, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
     if (pAllocateInfo->descriptorSetCount)
     {
-        uint64_t* cgen_var_415;
-        stream->alloc((void**)&cgen_var_415, pAllocateInfo->descriptorSetCount * 8);
-        stream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_415, pAllocateInfo->descriptorSetCount);
-        stream->write((uint64_t*)cgen_var_415, pAllocateInfo->descriptorSetCount * 8);
+        uint64_t* cgen_var_423;
+        stream->alloc((void**)&cgen_var_423, pAllocateInfo->descriptorSetCount * 8);
+        stream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_423, pAllocateInfo->descriptorSetCount);
+        stream->write((uint64_t*)cgen_var_423, pAllocateInfo->descriptorSetCount * 8);
     }
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
     if (pAllocateInfo->descriptorSetCount)
     {
-        uint64_t* cgen_var_416;
-        stream->alloc((void**)&cgen_var_416, pAllocateInfo->descriptorSetCount * 8);
-        stream->read((uint64_t*)cgen_var_416, pAllocateInfo->descriptorSetCount * 8);
-        stream->handleMapping()->mapHandles_u64_VkDescriptorSet(cgen_var_416, (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
+        uint64_t* cgen_var_424;
+        stream->alloc((void**)&cgen_var_424, pAllocateInfo->descriptorSetCount * 8);
+        stream->read((uint64_t*)cgen_var_424, pAllocateInfo->descriptorSetCount * 8);
+        stream->handleMapping()->mapHandles_u64_VkDescriptorSet(cgen_var_424, (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
     }
     stream->unsetHandleMapping();
     VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
@@ -5521,24 +5620,24 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_417;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_417, 1);
-        countingStream->write((uint64_t*)&cgen_var_417, 1 * 8);
-        uint64_t cgen_var_418;
-        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_418, 1);
-        countingStream->write((uint64_t*)&cgen_var_418, 1 * 8);
+        uint64_t cgen_var_425;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_425, 1);
+        countingStream->write((uint64_t*)&cgen_var_425, 1 * 8);
+        uint64_t cgen_var_426;
+        countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_426, 1);
+        countingStream->write((uint64_t*)&cgen_var_426, 1 * 8);
         countingStream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
         // WARNING PTR CHECK
-        uint64_t cgen_var_419 = (uint64_t)(uintptr_t)local_pDescriptorSets;
-        countingStream->putBe64(cgen_var_419);
+        uint64_t cgen_var_427 = (uint64_t)(uintptr_t)local_pDescriptorSets;
+        countingStream->putBe64(cgen_var_427);
         if (local_pDescriptorSets)
         {
             if (((descriptorSetCount)))
             {
-                uint64_t* cgen_var_420;
-                countingStream->alloc((void**)&cgen_var_420, ((descriptorSetCount)) * 8);
-                countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_420, ((descriptorSetCount)));
-                countingStream->write((uint64_t*)cgen_var_420, ((descriptorSetCount)) * 8);
+                uint64_t* cgen_var_428;
+                countingStream->alloc((void**)&cgen_var_428, ((descriptorSetCount)) * 8);
+                countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_428, ((descriptorSetCount)));
+                countingStream->write((uint64_t*)cgen_var_428, ((descriptorSetCount)) * 8);
             }
         }
     }
@@ -5547,24 +5646,24 @@
     uint32_t opcode_vkFreeDescriptorSets = OP_vkFreeDescriptorSets;
     stream->write(&opcode_vkFreeDescriptorSets, sizeof(uint32_t));
     stream->write(&packetSize_vkFreeDescriptorSets, sizeof(uint32_t));
-    uint64_t cgen_var_421;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_421, 1);
-    stream->write((uint64_t*)&cgen_var_421, 1 * 8);
-    uint64_t cgen_var_422;
-    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_422, 1);
-    stream->write((uint64_t*)&cgen_var_422, 1 * 8);
+    uint64_t cgen_var_429;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_429, 1);
+    stream->write((uint64_t*)&cgen_var_429, 1 * 8);
+    uint64_t cgen_var_430;
+    stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_430, 1);
+    stream->write((uint64_t*)&cgen_var_430, 1 * 8);
     stream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_423 = (uint64_t)(uintptr_t)local_pDescriptorSets;
-    stream->putBe64(cgen_var_423);
+    uint64_t cgen_var_431 = (uint64_t)(uintptr_t)local_pDescriptorSets;
+    stream->putBe64(cgen_var_431);
     if (local_pDescriptorSets)
     {
         if (((descriptorSetCount)))
         {
-            uint64_t* cgen_var_424;
-            stream->alloc((void**)&cgen_var_424, ((descriptorSetCount)) * 8);
-            stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_424, ((descriptorSetCount)));
-            stream->write((uint64_t*)cgen_var_424, ((descriptorSetCount)) * 8);
+            uint64_t* cgen_var_432;
+            stream->alloc((void**)&cgen_var_432, ((descriptorSetCount)) * 8);
+            stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_432, ((descriptorSetCount)));
+            stream->write((uint64_t*)cgen_var_432, ((descriptorSetCount)) * 8);
         }
     }
     VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
@@ -5635,9 +5734,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_425;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_425, 1);
-        countingStream->write((uint64_t*)&cgen_var_425, 1 * 8);
+        uint64_t cgen_var_433;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_433, 1);
+        countingStream->write((uint64_t*)&cgen_var_433, 1 * 8);
         countingStream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
         {
@@ -5654,9 +5753,9 @@
     uint32_t opcode_vkUpdateDescriptorSets = OP_vkUpdateDescriptorSets;
     stream->write(&opcode_vkUpdateDescriptorSets, sizeof(uint32_t));
     stream->write(&packetSize_vkUpdateDescriptorSets, sizeof(uint32_t));
-    uint64_t cgen_var_426;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_426, 1);
-    stream->write((uint64_t*)&cgen_var_426, 1 * 8);
+    uint64_t cgen_var_434;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_434, 1);
+    stream->write((uint64_t*)&cgen_var_434, 1 * 8);
     stream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
     {
@@ -5709,46 +5808,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_427;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_427, 1);
-        countingStream->write((uint64_t*)&cgen_var_427, 1 * 8);
+        uint64_t cgen_var_435;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_435, 1);
+        countingStream->write((uint64_t*)&cgen_var_435, 1 * 8);
         marshal_VkFramebufferCreateInfo(countingStream, (VkFramebufferCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_428 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_428);
+        uint64_t cgen_var_436 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_436);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_429;
-        countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_429, 1);
-        countingStream->write((uint64_t*)&cgen_var_429, 8);
+        uint64_t cgen_var_437;
+        countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_437, 1);
+        countingStream->write((uint64_t*)&cgen_var_437, 8);
     }
     uint32_t packetSize_vkCreateFramebuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateFramebuffer = OP_vkCreateFramebuffer;
     stream->write(&opcode_vkCreateFramebuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateFramebuffer, sizeof(uint32_t));
-    uint64_t cgen_var_430;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_430, 1);
-    stream->write((uint64_t*)&cgen_var_430, 1 * 8);
+    uint64_t cgen_var_438;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_438, 1);
+    stream->write((uint64_t*)&cgen_var_438, 1 * 8);
     marshal_VkFramebufferCreateInfo(stream, (VkFramebufferCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_431 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_431);
+    uint64_t cgen_var_439 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_439);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_432;
-    stream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_432, 1);
-    stream->write((uint64_t*)&cgen_var_432, 8);
+    uint64_t cgen_var_440;
+    stream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_440, 1);
+    stream->write((uint64_t*)&cgen_var_440, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_433;
-    stream->read((uint64_t*)&cgen_var_433, 8);
-    stream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_433, (VkFramebuffer*)pFramebuffer, 1);
+    uint64_t cgen_var_441;
+    stream->read((uint64_t*)&cgen_var_441, 8);
+    stream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_441, (VkFramebuffer*)pFramebuffer, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
     stream->read(&vkCreateFramebuffer_VkResult_return, sizeof(VkResult));
@@ -5788,15 +5887,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_434;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_434, 1);
-        countingStream->write((uint64_t*)&cgen_var_434, 1 * 8);
-        uint64_t cgen_var_435;
-        countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_435, 1);
-        countingStream->write((uint64_t*)&cgen_var_435, 1 * 8);
+        uint64_t cgen_var_442;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_442, 1);
+        countingStream->write((uint64_t*)&cgen_var_442, 1 * 8);
+        uint64_t cgen_var_443;
+        countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_443, 1);
+        countingStream->write((uint64_t*)&cgen_var_443, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_436 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_436);
+        uint64_t cgen_var_444 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_444);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5807,15 +5906,15 @@
     uint32_t opcode_vkDestroyFramebuffer = OP_vkDestroyFramebuffer;
     stream->write(&opcode_vkDestroyFramebuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyFramebuffer, sizeof(uint32_t));
-    uint64_t cgen_var_437;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_437, 1);
-    stream->write((uint64_t*)&cgen_var_437, 1 * 8);
-    uint64_t cgen_var_438;
-    stream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_438, 1);
-    stream->write((uint64_t*)&cgen_var_438, 1 * 8);
+    uint64_t cgen_var_445;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_445, 1);
+    stream->write((uint64_t*)&cgen_var_445, 1 * 8);
+    uint64_t cgen_var_446;
+    stream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_446, 1);
+    stream->write((uint64_t*)&cgen_var_446, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_439 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_439);
+    uint64_t cgen_var_447 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_447);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5863,46 +5962,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_440;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_440, 1);
-        countingStream->write((uint64_t*)&cgen_var_440, 1 * 8);
+        uint64_t cgen_var_448;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_448, 1);
+        countingStream->write((uint64_t*)&cgen_var_448, 1 * 8);
         marshal_VkRenderPassCreateInfo(countingStream, (VkRenderPassCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_441 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_441);
+        uint64_t cgen_var_449 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_449);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_442;
-        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_442, 1);
-        countingStream->write((uint64_t*)&cgen_var_442, 8);
+        uint64_t cgen_var_450;
+        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_450, 1);
+        countingStream->write((uint64_t*)&cgen_var_450, 8);
     }
     uint32_t packetSize_vkCreateRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateRenderPass = OP_vkCreateRenderPass;
     stream->write(&opcode_vkCreateRenderPass, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateRenderPass, sizeof(uint32_t));
-    uint64_t cgen_var_443;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_443, 1);
-    stream->write((uint64_t*)&cgen_var_443, 1 * 8);
+    uint64_t cgen_var_451;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_451, 1);
+    stream->write((uint64_t*)&cgen_var_451, 1 * 8);
     marshal_VkRenderPassCreateInfo(stream, (VkRenderPassCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_444 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_444);
+    uint64_t cgen_var_452 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_452);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_445;
-    stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_445, 1);
-    stream->write((uint64_t*)&cgen_var_445, 8);
+    uint64_t cgen_var_453;
+    stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_453, 1);
+    stream->write((uint64_t*)&cgen_var_453, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_446;
-    stream->read((uint64_t*)&cgen_var_446, 8);
-    stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_446, (VkRenderPass*)pRenderPass, 1);
+    uint64_t cgen_var_454;
+    stream->read((uint64_t*)&cgen_var_454, 8);
+    stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_454, (VkRenderPass*)pRenderPass, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
     stream->read(&vkCreateRenderPass_VkResult_return, sizeof(VkResult));
@@ -5942,15 +6041,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_447;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_447, 1);
-        countingStream->write((uint64_t*)&cgen_var_447, 1 * 8);
-        uint64_t cgen_var_448;
-        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_448, 1);
-        countingStream->write((uint64_t*)&cgen_var_448, 1 * 8);
+        uint64_t cgen_var_455;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_455, 1);
+        countingStream->write((uint64_t*)&cgen_var_455, 1 * 8);
+        uint64_t cgen_var_456;
+        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_456, 1);
+        countingStream->write((uint64_t*)&cgen_var_456, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_449 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_449);
+        uint64_t cgen_var_457 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_457);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5961,15 +6060,15 @@
     uint32_t opcode_vkDestroyRenderPass = OP_vkDestroyRenderPass;
     stream->write(&opcode_vkDestroyRenderPass, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyRenderPass, sizeof(uint32_t));
-    uint64_t cgen_var_450;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_450, 1);
-    stream->write((uint64_t*)&cgen_var_450, 1 * 8);
-    uint64_t cgen_var_451;
-    stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_451, 1);
-    stream->write((uint64_t*)&cgen_var_451, 1 * 8);
+    uint64_t cgen_var_458;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_458, 1);
+    stream->write((uint64_t*)&cgen_var_458, 1 * 8);
+    uint64_t cgen_var_459;
+    stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_459, 1);
+    stream->write((uint64_t*)&cgen_var_459, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_452 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_452);
+    uint64_t cgen_var_460 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_460);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5995,12 +6094,12 @@
     local_renderPass = renderPass;
     countingStream->rewind();
     {
-        uint64_t cgen_var_453;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_453, 1);
-        countingStream->write((uint64_t*)&cgen_var_453, 1 * 8);
-        uint64_t cgen_var_454;
-        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_454, 1);
-        countingStream->write((uint64_t*)&cgen_var_454, 1 * 8);
+        uint64_t cgen_var_461;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_461, 1);
+        countingStream->write((uint64_t*)&cgen_var_461, 1 * 8);
+        uint64_t cgen_var_462;
+        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_462, 1);
+        countingStream->write((uint64_t*)&cgen_var_462, 1 * 8);
         marshal_VkExtent2D(countingStream, (VkExtent2D*)(pGranularity));
     }
     uint32_t packetSize_vkGetRenderAreaGranularity = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6008,12 +6107,12 @@
     uint32_t opcode_vkGetRenderAreaGranularity = OP_vkGetRenderAreaGranularity;
     stream->write(&opcode_vkGetRenderAreaGranularity, sizeof(uint32_t));
     stream->write(&packetSize_vkGetRenderAreaGranularity, sizeof(uint32_t));
-    uint64_t cgen_var_455;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_455, 1);
-    stream->write((uint64_t*)&cgen_var_455, 1 * 8);
-    uint64_t cgen_var_456;
-    stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_456, 1);
-    stream->write((uint64_t*)&cgen_var_456, 1 * 8);
+    uint64_t cgen_var_463;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_463, 1);
+    stream->write((uint64_t*)&cgen_var_463, 1 * 8);
+    uint64_t cgen_var_464;
+    stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_464, 1);
+    stream->write((uint64_t*)&cgen_var_464, 1 * 8);
     marshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
     unmarshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
     if (pGranularity)
@@ -6062,46 +6161,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_457;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_457, 1);
-        countingStream->write((uint64_t*)&cgen_var_457, 1 * 8);
+        uint64_t cgen_var_465;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_465, 1);
+        countingStream->write((uint64_t*)&cgen_var_465, 1 * 8);
         marshal_VkCommandPoolCreateInfo(countingStream, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_458 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_458);
+        uint64_t cgen_var_466 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_466);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_459;
-        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_459, 1);
-        countingStream->write((uint64_t*)&cgen_var_459, 8);
+        uint64_t cgen_var_467;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_467, 1);
+        countingStream->write((uint64_t*)&cgen_var_467, 8);
     }
     uint32_t packetSize_vkCreateCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateCommandPool = OP_vkCreateCommandPool;
     stream->write(&opcode_vkCreateCommandPool, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateCommandPool, sizeof(uint32_t));
-    uint64_t cgen_var_460;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_460, 1);
-    stream->write((uint64_t*)&cgen_var_460, 1 * 8);
+    uint64_t cgen_var_468;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_468, 1);
+    stream->write((uint64_t*)&cgen_var_468, 1 * 8);
     marshal_VkCommandPoolCreateInfo(stream, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_461 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_461);
+    uint64_t cgen_var_469 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_469);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_462;
-    stream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_462, 1);
-    stream->write((uint64_t*)&cgen_var_462, 8);
+    uint64_t cgen_var_470;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_470, 1);
+    stream->write((uint64_t*)&cgen_var_470, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_463;
-    stream->read((uint64_t*)&cgen_var_463, 8);
-    stream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_463, (VkCommandPool*)pCommandPool, 1);
+    uint64_t cgen_var_471;
+    stream->read((uint64_t*)&cgen_var_471, 8);
+    stream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_471, (VkCommandPool*)pCommandPool, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
     stream->read(&vkCreateCommandPool_VkResult_return, sizeof(VkResult));
@@ -6141,15 +6240,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_464;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_464, 1);
-        countingStream->write((uint64_t*)&cgen_var_464, 1 * 8);
-        uint64_t cgen_var_465;
-        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_465, 1);
-        countingStream->write((uint64_t*)&cgen_var_465, 1 * 8);
+        uint64_t cgen_var_472;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_472, 1);
+        countingStream->write((uint64_t*)&cgen_var_472, 1 * 8);
+        uint64_t cgen_var_473;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_473, 1);
+        countingStream->write((uint64_t*)&cgen_var_473, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_466 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_466);
+        uint64_t cgen_var_474 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_474);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -6160,15 +6259,15 @@
     uint32_t opcode_vkDestroyCommandPool = OP_vkDestroyCommandPool;
     stream->write(&opcode_vkDestroyCommandPool, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyCommandPool, sizeof(uint32_t));
-    uint64_t cgen_var_467;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_467, 1);
-    stream->write((uint64_t*)&cgen_var_467, 1 * 8);
-    uint64_t cgen_var_468;
-    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_468, 1);
-    stream->write((uint64_t*)&cgen_var_468, 1 * 8);
+    uint64_t cgen_var_475;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_475, 1);
+    stream->write((uint64_t*)&cgen_var_475, 1 * 8);
+    uint64_t cgen_var_476;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_476, 1);
+    stream->write((uint64_t*)&cgen_var_476, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_469 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_469);
+    uint64_t cgen_var_477 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_477);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -6196,12 +6295,12 @@
     local_flags = flags;
     countingStream->rewind();
     {
-        uint64_t cgen_var_470;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_470, 1);
-        countingStream->write((uint64_t*)&cgen_var_470, 1 * 8);
-        uint64_t cgen_var_471;
-        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_471, 1);
-        countingStream->write((uint64_t*)&cgen_var_471, 1 * 8);
+        uint64_t cgen_var_478;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_478, 1);
+        countingStream->write((uint64_t*)&cgen_var_478, 1 * 8);
+        uint64_t cgen_var_479;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_479, 1);
+        countingStream->write((uint64_t*)&cgen_var_479, 1 * 8);
         countingStream->write((VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags));
     }
     uint32_t packetSize_vkResetCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6209,12 +6308,12 @@
     uint32_t opcode_vkResetCommandPool = OP_vkResetCommandPool;
     stream->write(&opcode_vkResetCommandPool, sizeof(uint32_t));
     stream->write(&packetSize_vkResetCommandPool, sizeof(uint32_t));
-    uint64_t cgen_var_472;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_472, 1);
-    stream->write((uint64_t*)&cgen_var_472, 1 * 8);
-    uint64_t cgen_var_473;
-    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_473, 1);
-    stream->write((uint64_t*)&cgen_var_473, 1 * 8);
+    uint64_t cgen_var_480;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_480, 1);
+    stream->write((uint64_t*)&cgen_var_480, 1 * 8);
+    uint64_t cgen_var_481;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_481, 1);
+    stream->write((uint64_t*)&cgen_var_481, 1 * 8);
     stream->write((VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags));
     VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
     stream->read(&vkResetCommandPool_VkResult_return, sizeof(VkResult));
@@ -6251,16 +6350,16 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_474;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_474, 1);
-        countingStream->write((uint64_t*)&cgen_var_474, 1 * 8);
+        uint64_t cgen_var_482;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_482, 1);
+        countingStream->write((uint64_t*)&cgen_var_482, 1 * 8);
         marshal_VkCommandBufferAllocateInfo(countingStream, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
         if (pAllocateInfo->commandBufferCount)
         {
-            uint64_t* cgen_var_475;
-            countingStream->alloc((void**)&cgen_var_475, pAllocateInfo->commandBufferCount * 8);
-            countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_475, pAllocateInfo->commandBufferCount);
-            countingStream->write((uint64_t*)cgen_var_475, pAllocateInfo->commandBufferCount * 8);
+            uint64_t* cgen_var_483;
+            countingStream->alloc((void**)&cgen_var_483, pAllocateInfo->commandBufferCount * 8);
+            countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_483, pAllocateInfo->commandBufferCount);
+            countingStream->write((uint64_t*)cgen_var_483, pAllocateInfo->commandBufferCount * 8);
         }
     }
     uint32_t packetSize_vkAllocateCommandBuffers = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6268,26 +6367,26 @@
     uint32_t opcode_vkAllocateCommandBuffers = OP_vkAllocateCommandBuffers;
     stream->write(&opcode_vkAllocateCommandBuffers, sizeof(uint32_t));
     stream->write(&packetSize_vkAllocateCommandBuffers, sizeof(uint32_t));
-    uint64_t cgen_var_476;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_476, 1);
-    stream->write((uint64_t*)&cgen_var_476, 1 * 8);
+    uint64_t cgen_var_484;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_484, 1);
+    stream->write((uint64_t*)&cgen_var_484, 1 * 8);
     marshal_VkCommandBufferAllocateInfo(stream, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
     if (pAllocateInfo->commandBufferCount)
     {
-        uint64_t* cgen_var_477;
-        stream->alloc((void**)&cgen_var_477, pAllocateInfo->commandBufferCount * 8);
-        stream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_477, pAllocateInfo->commandBufferCount);
-        stream->write((uint64_t*)cgen_var_477, pAllocateInfo->commandBufferCount * 8);
+        uint64_t* cgen_var_485;
+        stream->alloc((void**)&cgen_var_485, pAllocateInfo->commandBufferCount * 8);
+        stream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_485, pAllocateInfo->commandBufferCount);
+        stream->write((uint64_t*)cgen_var_485, pAllocateInfo->commandBufferCount * 8);
     }
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
     if (pAllocateInfo->commandBufferCount)
     {
-        uint64_t* cgen_var_478;
-        stream->alloc((void**)&cgen_var_478, pAllocateInfo->commandBufferCount * 8);
-        stream->read((uint64_t*)cgen_var_478, pAllocateInfo->commandBufferCount * 8);
-        stream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_478, (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount);
+        uint64_t* cgen_var_486;
+        stream->alloc((void**)&cgen_var_486, pAllocateInfo->commandBufferCount * 8);
+        stream->read((uint64_t*)cgen_var_486, pAllocateInfo->commandBufferCount * 8);
+        stream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_486, (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount);
     }
     stream->unsetHandleMapping();
     VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
@@ -6325,24 +6424,24 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_479;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_479, 1);
-        countingStream->write((uint64_t*)&cgen_var_479, 1 * 8);
-        uint64_t cgen_var_480;
-        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_480, 1);
-        countingStream->write((uint64_t*)&cgen_var_480, 1 * 8);
+        uint64_t cgen_var_487;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_487, 1);
+        countingStream->write((uint64_t*)&cgen_var_487, 1 * 8);
+        uint64_t cgen_var_488;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_488, 1);
+        countingStream->write((uint64_t*)&cgen_var_488, 1 * 8);
         countingStream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
         // WARNING PTR CHECK
-        uint64_t cgen_var_481 = (uint64_t)(uintptr_t)local_pCommandBuffers;
-        countingStream->putBe64(cgen_var_481);
+        uint64_t cgen_var_489 = (uint64_t)(uintptr_t)local_pCommandBuffers;
+        countingStream->putBe64(cgen_var_489);
         if (local_pCommandBuffers)
         {
             if (((commandBufferCount)))
             {
-                uint64_t* cgen_var_482;
-                countingStream->alloc((void**)&cgen_var_482, ((commandBufferCount)) * 8);
-                countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_482, ((commandBufferCount)));
-                countingStream->write((uint64_t*)cgen_var_482, ((commandBufferCount)) * 8);
+                uint64_t* cgen_var_490;
+                countingStream->alloc((void**)&cgen_var_490, ((commandBufferCount)) * 8);
+                countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_490, ((commandBufferCount)));
+                countingStream->write((uint64_t*)cgen_var_490, ((commandBufferCount)) * 8);
             }
         }
     }
@@ -6351,24 +6450,24 @@
     uint32_t opcode_vkFreeCommandBuffers = OP_vkFreeCommandBuffers;
     stream->write(&opcode_vkFreeCommandBuffers, sizeof(uint32_t));
     stream->write(&packetSize_vkFreeCommandBuffers, sizeof(uint32_t));
-    uint64_t cgen_var_483;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_483, 1);
-    stream->write((uint64_t*)&cgen_var_483, 1 * 8);
-    uint64_t cgen_var_484;
-    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_484, 1);
-    stream->write((uint64_t*)&cgen_var_484, 1 * 8);
+    uint64_t cgen_var_491;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_491, 1);
+    stream->write((uint64_t*)&cgen_var_491, 1 * 8);
+    uint64_t cgen_var_492;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_492, 1);
+    stream->write((uint64_t*)&cgen_var_492, 1 * 8);
     stream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_485 = (uint64_t)(uintptr_t)local_pCommandBuffers;
-    stream->putBe64(cgen_var_485);
+    uint64_t cgen_var_493 = (uint64_t)(uintptr_t)local_pCommandBuffers;
+    stream->putBe64(cgen_var_493);
     if (local_pCommandBuffers)
     {
         if (((commandBufferCount)))
         {
-            uint64_t* cgen_var_486;
-            stream->alloc((void**)&cgen_var_486, ((commandBufferCount)) * 8);
-            stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_486, ((commandBufferCount)));
-            stream->write((uint64_t*)cgen_var_486, ((commandBufferCount)) * 8);
+            uint64_t* cgen_var_494;
+            stream->alloc((void**)&cgen_var_494, ((commandBufferCount)) * 8);
+            stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_494, ((commandBufferCount)));
+            stream->write((uint64_t*)cgen_var_494, ((commandBufferCount)) * 8);
         }
     }
     if (pCommandBuffers)
@@ -6403,9 +6502,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_487;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_487, 1);
-        countingStream->write((uint64_t*)&cgen_var_487, 1 * 8);
+        uint64_t cgen_var_495;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_495, 1);
+        countingStream->write((uint64_t*)&cgen_var_495, 1 * 8);
         marshal_VkCommandBufferBeginInfo(countingStream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
     }
     uint32_t packetSize_vkBeginCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6413,9 +6512,9 @@
     uint32_t opcode_vkBeginCommandBuffer = OP_vkBeginCommandBuffer;
     stream->write(&opcode_vkBeginCommandBuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkBeginCommandBuffer, sizeof(uint32_t));
-    uint64_t cgen_var_488;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_488, 1);
-    stream->write((uint64_t*)&cgen_var_488, 1 * 8);
+    uint64_t cgen_var_496;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_496, 1);
+    stream->write((uint64_t*)&cgen_var_496, 1 * 8);
     marshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
     VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkBeginCommandBuffer_VkResult_return, sizeof(VkResult));
@@ -6439,18 +6538,18 @@
     local_commandBuffer = commandBuffer;
     countingStream->rewind();
     {
-        uint64_t cgen_var_489;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_489, 1);
-        countingStream->write((uint64_t*)&cgen_var_489, 1 * 8);
+        uint64_t cgen_var_497;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_497, 1);
+        countingStream->write((uint64_t*)&cgen_var_497, 1 * 8);
     }
     uint32_t packetSize_vkEndCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkEndCommandBuffer = OP_vkEndCommandBuffer;
     stream->write(&opcode_vkEndCommandBuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkEndCommandBuffer, sizeof(uint32_t));
-    uint64_t cgen_var_490;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_490, 1);
-    stream->write((uint64_t*)&cgen_var_490, 1 * 8);
+    uint64_t cgen_var_498;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_498, 1);
+    stream->write((uint64_t*)&cgen_var_498, 1 * 8);
     VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkEndCommandBuffer_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -6476,9 +6575,9 @@
     local_flags = flags;
     countingStream->rewind();
     {
-        uint64_t cgen_var_491;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_491, 1);
-        countingStream->write((uint64_t*)&cgen_var_491, 1 * 8);
+        uint64_t cgen_var_499;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_499, 1);
+        countingStream->write((uint64_t*)&cgen_var_499, 1 * 8);
         countingStream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
     }
     uint32_t packetSize_vkResetCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6486,9 +6585,9 @@
     uint32_t opcode_vkResetCommandBuffer = OP_vkResetCommandBuffer;
     stream->write(&opcode_vkResetCommandBuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkResetCommandBuffer, sizeof(uint32_t));
-    uint64_t cgen_var_492;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_492, 1);
-    stream->write((uint64_t*)&cgen_var_492, 1 * 8);
+    uint64_t cgen_var_500;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_500, 1);
+    stream->write((uint64_t*)&cgen_var_500, 1 * 8);
     stream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
     VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkResetCommandBuffer_VkResult_return, sizeof(VkResult));
@@ -6518,26 +6617,26 @@
     local_pipeline = pipeline;
     countingStream->rewind();
     {
-        uint64_t cgen_var_493;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_493, 1);
-        countingStream->write((uint64_t*)&cgen_var_493, 1 * 8);
+        uint64_t cgen_var_501;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_501, 1);
+        countingStream->write((uint64_t*)&cgen_var_501, 1 * 8);
         countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
-        uint64_t cgen_var_494;
-        countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_494, 1);
-        countingStream->write((uint64_t*)&cgen_var_494, 1 * 8);
+        uint64_t cgen_var_502;
+        countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_502, 1);
+        countingStream->write((uint64_t*)&cgen_var_502, 1 * 8);
     }
     uint32_t packetSize_vkCmdBindPipeline = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCmdBindPipeline = OP_vkCmdBindPipeline;
     stream->write(&opcode_vkCmdBindPipeline, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdBindPipeline, sizeof(uint32_t));
-    uint64_t cgen_var_495;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_495, 1);
-    stream->write((uint64_t*)&cgen_var_495, 1 * 8);
+    uint64_t cgen_var_503;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_503, 1);
+    stream->write((uint64_t*)&cgen_var_503, 1 * 8);
     stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
-    uint64_t cgen_var_496;
-    stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_496, 1);
-    stream->write((uint64_t*)&cgen_var_496, 1 * 8);
+    uint64_t cgen_var_504;
+    stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_504, 1);
+    stream->write((uint64_t*)&cgen_var_504, 1 * 8);
     mImpl->log("finish vkCmdBindPipeline");;
 }
 
@@ -6578,9 +6677,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_497;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_497, 1);
-        countingStream->write((uint64_t*)&cgen_var_497, 1 * 8);
+        uint64_t cgen_var_505;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_505, 1);
+        countingStream->write((uint64_t*)&cgen_var_505, 1 * 8);
         countingStream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
@@ -6593,9 +6692,9 @@
     uint32_t opcode_vkCmdSetViewport = OP_vkCmdSetViewport;
     stream->write(&opcode_vkCmdSetViewport, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetViewport, sizeof(uint32_t));
-    uint64_t cgen_var_498;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_498, 1);
-    stream->write((uint64_t*)&cgen_var_498, 1 * 8);
+    uint64_t cgen_var_506;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_506, 1);
+    stream->write((uint64_t*)&cgen_var_506, 1 * 8);
     stream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
     stream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
@@ -6642,9 +6741,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_499;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_499, 1);
-        countingStream->write((uint64_t*)&cgen_var_499, 1 * 8);
+        uint64_t cgen_var_507;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_507, 1);
+        countingStream->write((uint64_t*)&cgen_var_507, 1 * 8);
         countingStream->write((uint32_t*)&local_firstScissor, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_scissorCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
@@ -6657,9 +6756,9 @@
     uint32_t opcode_vkCmdSetScissor = OP_vkCmdSetScissor;
     stream->write(&opcode_vkCmdSetScissor, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetScissor, sizeof(uint32_t));
-    uint64_t cgen_var_500;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_500, 1);
-    stream->write((uint64_t*)&cgen_var_500, 1 * 8);
+    uint64_t cgen_var_508;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_508, 1);
+    stream->write((uint64_t*)&cgen_var_508, 1 * 8);
     stream->write((uint32_t*)&local_firstScissor, sizeof(uint32_t));
     stream->write((uint32_t*)&local_scissorCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
@@ -6685,9 +6784,9 @@
     local_lineWidth = lineWidth;
     countingStream->rewind();
     {
-        uint64_t cgen_var_501;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_501, 1);
-        countingStream->write((uint64_t*)&cgen_var_501, 1 * 8);
+        uint64_t cgen_var_509;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_509, 1);
+        countingStream->write((uint64_t*)&cgen_var_509, 1 * 8);
         countingStream->write((float*)&local_lineWidth, sizeof(float));
     }
     uint32_t packetSize_vkCmdSetLineWidth = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6695,9 +6794,9 @@
     uint32_t opcode_vkCmdSetLineWidth = OP_vkCmdSetLineWidth;
     stream->write(&opcode_vkCmdSetLineWidth, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetLineWidth, sizeof(uint32_t));
-    uint64_t cgen_var_502;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_502, 1);
-    stream->write((uint64_t*)&cgen_var_502, 1 * 8);
+    uint64_t cgen_var_510;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_510, 1);
+    stream->write((uint64_t*)&cgen_var_510, 1 * 8);
     stream->write((float*)&local_lineWidth, sizeof(float));
     mImpl->log("finish vkCmdSetLineWidth");;
 }
@@ -6724,9 +6823,9 @@
     local_depthBiasSlopeFactor = depthBiasSlopeFactor;
     countingStream->rewind();
     {
-        uint64_t cgen_var_503;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_503, 1);
-        countingStream->write((uint64_t*)&cgen_var_503, 1 * 8);
+        uint64_t cgen_var_511;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_511, 1);
+        countingStream->write((uint64_t*)&cgen_var_511, 1 * 8);
         countingStream->write((float*)&local_depthBiasConstantFactor, sizeof(float));
         countingStream->write((float*)&local_depthBiasClamp, sizeof(float));
         countingStream->write((float*)&local_depthBiasSlopeFactor, sizeof(float));
@@ -6736,9 +6835,9 @@
     uint32_t opcode_vkCmdSetDepthBias = OP_vkCmdSetDepthBias;
     stream->write(&opcode_vkCmdSetDepthBias, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetDepthBias, sizeof(uint32_t));
-    uint64_t cgen_var_504;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_504, 1);
-    stream->write((uint64_t*)&cgen_var_504, 1 * 8);
+    uint64_t cgen_var_512;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_512, 1);
+    stream->write((uint64_t*)&cgen_var_512, 1 * 8);
     stream->write((float*)&local_depthBiasConstantFactor, sizeof(float));
     stream->write((float*)&local_depthBiasClamp, sizeof(float));
     stream->write((float*)&local_depthBiasSlopeFactor, sizeof(float));
@@ -6761,9 +6860,9 @@
     memcpy(&local_blendConstants, &blendConstants, 4 * sizeof(const float));
     countingStream->rewind();
     {
-        uint64_t cgen_var_505;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_505, 1);
-        countingStream->write((uint64_t*)&cgen_var_505, 1 * 8);
+        uint64_t cgen_var_513;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_513, 1);
+        countingStream->write((uint64_t*)&cgen_var_513, 1 * 8);
         countingStream->write((float*)&local_blendConstants, 4 * sizeof(float));
     }
     uint32_t packetSize_vkCmdSetBlendConstants = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6771,9 +6870,9 @@
     uint32_t opcode_vkCmdSetBlendConstants = OP_vkCmdSetBlendConstants;
     stream->write(&opcode_vkCmdSetBlendConstants, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetBlendConstants, sizeof(uint32_t));
-    uint64_t cgen_var_506;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_506, 1);
-    stream->write((uint64_t*)&cgen_var_506, 1 * 8);
+    uint64_t cgen_var_514;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_514, 1);
+    stream->write((uint64_t*)&cgen_var_514, 1 * 8);
     stream->write((float*)&local_blendConstants, 4 * sizeof(float));
     mImpl->log("finish vkCmdSetBlendConstants");;
 }
@@ -6797,9 +6896,9 @@
     local_maxDepthBounds = maxDepthBounds;
     countingStream->rewind();
     {
-        uint64_t cgen_var_507;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_507, 1);
-        countingStream->write((uint64_t*)&cgen_var_507, 1 * 8);
+        uint64_t cgen_var_515;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_515, 1);
+        countingStream->write((uint64_t*)&cgen_var_515, 1 * 8);
         countingStream->write((float*)&local_minDepthBounds, sizeof(float));
         countingStream->write((float*)&local_maxDepthBounds, sizeof(float));
     }
@@ -6808,9 +6907,9 @@
     uint32_t opcode_vkCmdSetDepthBounds = OP_vkCmdSetDepthBounds;
     stream->write(&opcode_vkCmdSetDepthBounds, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetDepthBounds, sizeof(uint32_t));
-    uint64_t cgen_var_508;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_508, 1);
-    stream->write((uint64_t*)&cgen_var_508, 1 * 8);
+    uint64_t cgen_var_516;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_516, 1);
+    stream->write((uint64_t*)&cgen_var_516, 1 * 8);
     stream->write((float*)&local_minDepthBounds, sizeof(float));
     stream->write((float*)&local_maxDepthBounds, sizeof(float));
     mImpl->log("finish vkCmdSetDepthBounds");;
@@ -6835,9 +6934,9 @@
     local_compareMask = compareMask;
     countingStream->rewind();
     {
-        uint64_t cgen_var_509;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_509, 1);
-        countingStream->write((uint64_t*)&cgen_var_509, 1 * 8);
+        uint64_t cgen_var_517;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_517, 1);
+        countingStream->write((uint64_t*)&cgen_var_517, 1 * 8);
         countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
         countingStream->write((uint32_t*)&local_compareMask, sizeof(uint32_t));
     }
@@ -6846,9 +6945,9 @@
     uint32_t opcode_vkCmdSetStencilCompareMask = OP_vkCmdSetStencilCompareMask;
     stream->write(&opcode_vkCmdSetStencilCompareMask, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetStencilCompareMask, sizeof(uint32_t));
-    uint64_t cgen_var_510;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_510, 1);
-    stream->write((uint64_t*)&cgen_var_510, 1 * 8);
+    uint64_t cgen_var_518;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_518, 1);
+    stream->write((uint64_t*)&cgen_var_518, 1 * 8);
     stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
     stream->write((uint32_t*)&local_compareMask, sizeof(uint32_t));
     mImpl->log("finish vkCmdSetStencilCompareMask");;
@@ -6873,9 +6972,9 @@
     local_writeMask = writeMask;
     countingStream->rewind();
     {
-        uint64_t cgen_var_511;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_511, 1);
-        countingStream->write((uint64_t*)&cgen_var_511, 1 * 8);
+        uint64_t cgen_var_519;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_519, 1);
+        countingStream->write((uint64_t*)&cgen_var_519, 1 * 8);
         countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
         countingStream->write((uint32_t*)&local_writeMask, sizeof(uint32_t));
     }
@@ -6884,9 +6983,9 @@
     uint32_t opcode_vkCmdSetStencilWriteMask = OP_vkCmdSetStencilWriteMask;
     stream->write(&opcode_vkCmdSetStencilWriteMask, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetStencilWriteMask, sizeof(uint32_t));
-    uint64_t cgen_var_512;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_512, 1);
-    stream->write((uint64_t*)&cgen_var_512, 1 * 8);
+    uint64_t cgen_var_520;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_520, 1);
+    stream->write((uint64_t*)&cgen_var_520, 1 * 8);
     stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
     stream->write((uint32_t*)&local_writeMask, sizeof(uint32_t));
     mImpl->log("finish vkCmdSetStencilWriteMask");;
@@ -6911,9 +7010,9 @@
     local_reference = reference;
     countingStream->rewind();
     {
-        uint64_t cgen_var_513;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_513, 1);
-        countingStream->write((uint64_t*)&cgen_var_513, 1 * 8);
+        uint64_t cgen_var_521;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_521, 1);
+        countingStream->write((uint64_t*)&cgen_var_521, 1 * 8);
         countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
         countingStream->write((uint32_t*)&local_reference, sizeof(uint32_t));
     }
@@ -6922,9 +7021,9 @@
     uint32_t opcode_vkCmdSetStencilReference = OP_vkCmdSetStencilReference;
     stream->write(&opcode_vkCmdSetStencilReference, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetStencilReference, sizeof(uint32_t));
-    uint64_t cgen_var_514;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_514, 1);
-    stream->write((uint64_t*)&cgen_var_514, 1 * 8);
+    uint64_t cgen_var_522;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_522, 1);
+    stream->write((uint64_t*)&cgen_var_522, 1 * 8);
     stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
     stream->write((uint32_t*)&local_reference, sizeof(uint32_t));
     mImpl->log("finish vkCmdSetStencilReference");;
@@ -6972,21 +7071,21 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_515;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_515, 1);
-        countingStream->write((uint64_t*)&cgen_var_515, 1 * 8);
+        uint64_t cgen_var_523;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_523, 1);
+        countingStream->write((uint64_t*)&cgen_var_523, 1 * 8);
         countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
-        uint64_t cgen_var_516;
-        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_516, 1);
-        countingStream->write((uint64_t*)&cgen_var_516, 1 * 8);
+        uint64_t cgen_var_524;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_524, 1);
+        countingStream->write((uint64_t*)&cgen_var_524, 1 * 8);
         countingStream->write((uint32_t*)&local_firstSet, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
         if (((descriptorSetCount)))
         {
-            uint64_t* cgen_var_517;
-            countingStream->alloc((void**)&cgen_var_517, ((descriptorSetCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_517, ((descriptorSetCount)));
-            countingStream->write((uint64_t*)cgen_var_517, ((descriptorSetCount)) * 8);
+            uint64_t* cgen_var_525;
+            countingStream->alloc((void**)&cgen_var_525, ((descriptorSetCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_525, ((descriptorSetCount)));
+            countingStream->write((uint64_t*)cgen_var_525, ((descriptorSetCount)) * 8);
         }
         countingStream->write((uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
@@ -6996,21 +7095,21 @@
     uint32_t opcode_vkCmdBindDescriptorSets = OP_vkCmdBindDescriptorSets;
     stream->write(&opcode_vkCmdBindDescriptorSets, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdBindDescriptorSets, sizeof(uint32_t));
-    uint64_t cgen_var_518;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_518, 1);
-    stream->write((uint64_t*)&cgen_var_518, 1 * 8);
+    uint64_t cgen_var_526;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_526, 1);
+    stream->write((uint64_t*)&cgen_var_526, 1 * 8);
     stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
-    uint64_t cgen_var_519;
-    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_519, 1);
-    stream->write((uint64_t*)&cgen_var_519, 1 * 8);
+    uint64_t cgen_var_527;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_527, 1);
+    stream->write((uint64_t*)&cgen_var_527, 1 * 8);
     stream->write((uint32_t*)&local_firstSet, sizeof(uint32_t));
     stream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
     if (((descriptorSetCount)))
     {
-        uint64_t* cgen_var_520;
-        stream->alloc((void**)&cgen_var_520, ((descriptorSetCount)) * 8);
-        stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_520, ((descriptorSetCount)));
-        stream->write((uint64_t*)cgen_var_520, ((descriptorSetCount)) * 8);
+        uint64_t* cgen_var_528;
+        stream->alloc((void**)&cgen_var_528, ((descriptorSetCount)) * 8);
+        stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_528, ((descriptorSetCount)));
+        stream->write((uint64_t*)cgen_var_528, ((descriptorSetCount)) * 8);
     }
     stream->write((uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t));
     stream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
@@ -7039,12 +7138,12 @@
     local_indexType = indexType;
     countingStream->rewind();
     {
-        uint64_t cgen_var_521;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_521, 1);
-        countingStream->write((uint64_t*)&cgen_var_521, 1 * 8);
-        uint64_t cgen_var_522;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_522, 1);
-        countingStream->write((uint64_t*)&cgen_var_522, 1 * 8);
+        uint64_t cgen_var_529;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_529, 1);
+        countingStream->write((uint64_t*)&cgen_var_529, 1 * 8);
+        uint64_t cgen_var_530;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_530, 1);
+        countingStream->write((uint64_t*)&cgen_var_530, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
         countingStream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType));
     }
@@ -7053,12 +7152,12 @@
     uint32_t opcode_vkCmdBindIndexBuffer = OP_vkCmdBindIndexBuffer;
     stream->write(&opcode_vkCmdBindIndexBuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdBindIndexBuffer, sizeof(uint32_t));
-    uint64_t cgen_var_523;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_523, 1);
-    stream->write((uint64_t*)&cgen_var_523, 1 * 8);
-    uint64_t cgen_var_524;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_524, 1);
-    stream->write((uint64_t*)&cgen_var_524, 1 * 8);
+    uint64_t cgen_var_531;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_531, 1);
+    stream->write((uint64_t*)&cgen_var_531, 1 * 8);
+    uint64_t cgen_var_532;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_532, 1);
+    stream->write((uint64_t*)&cgen_var_532, 1 * 8);
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
     stream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType));
     mImpl->log("finish vkCmdBindIndexBuffer");;
@@ -7097,17 +7196,17 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_525;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_525, 1);
-        countingStream->write((uint64_t*)&cgen_var_525, 1 * 8);
+        uint64_t cgen_var_533;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_533, 1);
+        countingStream->write((uint64_t*)&cgen_var_533, 1 * 8);
         countingStream->write((uint32_t*)&local_firstBinding, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_bindingCount, sizeof(uint32_t));
         if (((bindingCount)))
         {
-            uint64_t* cgen_var_526;
-            countingStream->alloc((void**)&cgen_var_526, ((bindingCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_526, ((bindingCount)));
-            countingStream->write((uint64_t*)cgen_var_526, ((bindingCount)) * 8);
+            uint64_t* cgen_var_534;
+            countingStream->alloc((void**)&cgen_var_534, ((bindingCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_534, ((bindingCount)));
+            countingStream->write((uint64_t*)cgen_var_534, ((bindingCount)) * 8);
         }
         countingStream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
     }
@@ -7116,17 +7215,17 @@
     uint32_t opcode_vkCmdBindVertexBuffers = OP_vkCmdBindVertexBuffers;
     stream->write(&opcode_vkCmdBindVertexBuffers, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdBindVertexBuffers, sizeof(uint32_t));
-    uint64_t cgen_var_527;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_527, 1);
-    stream->write((uint64_t*)&cgen_var_527, 1 * 8);
+    uint64_t cgen_var_535;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_535, 1);
+    stream->write((uint64_t*)&cgen_var_535, 1 * 8);
     stream->write((uint32_t*)&local_firstBinding, sizeof(uint32_t));
     stream->write((uint32_t*)&local_bindingCount, sizeof(uint32_t));
     if (((bindingCount)))
     {
-        uint64_t* cgen_var_528;
-        stream->alloc((void**)&cgen_var_528, ((bindingCount)) * 8);
-        stream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_528, ((bindingCount)));
-        stream->write((uint64_t*)cgen_var_528, ((bindingCount)) * 8);
+        uint64_t* cgen_var_536;
+        stream->alloc((void**)&cgen_var_536, ((bindingCount)) * 8);
+        stream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_536, ((bindingCount)));
+        stream->write((uint64_t*)cgen_var_536, ((bindingCount)) * 8);
     }
     stream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
     mImpl->log("finish vkCmdBindVertexBuffers");;
@@ -7157,9 +7256,9 @@
     local_firstInstance = firstInstance;
     countingStream->rewind();
     {
-        uint64_t cgen_var_529;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_529, 1);
-        countingStream->write((uint64_t*)&cgen_var_529, 1 * 8);
+        uint64_t cgen_var_537;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_537, 1);
+        countingStream->write((uint64_t*)&cgen_var_537, 1 * 8);
         countingStream->write((uint32_t*)&local_vertexCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_firstVertex, sizeof(uint32_t));
@@ -7170,9 +7269,9 @@
     uint32_t opcode_vkCmdDraw = OP_vkCmdDraw;
     stream->write(&opcode_vkCmdDraw, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDraw, sizeof(uint32_t));
-    uint64_t cgen_var_530;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_530, 1);
-    stream->write((uint64_t*)&cgen_var_530, 1 * 8);
+    uint64_t cgen_var_538;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_538, 1);
+    stream->write((uint64_t*)&cgen_var_538, 1 * 8);
     stream->write((uint32_t*)&local_vertexCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_firstVertex, sizeof(uint32_t));
@@ -7208,9 +7307,9 @@
     local_firstInstance = firstInstance;
     countingStream->rewind();
     {
-        uint64_t cgen_var_531;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_531, 1);
-        countingStream->write((uint64_t*)&cgen_var_531, 1 * 8);
+        uint64_t cgen_var_539;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_539, 1);
+        countingStream->write((uint64_t*)&cgen_var_539, 1 * 8);
         countingStream->write((uint32_t*)&local_indexCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_firstIndex, sizeof(uint32_t));
@@ -7222,9 +7321,9 @@
     uint32_t opcode_vkCmdDrawIndexed = OP_vkCmdDrawIndexed;
     stream->write(&opcode_vkCmdDrawIndexed, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDrawIndexed, sizeof(uint32_t));
-    uint64_t cgen_var_532;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_532, 1);
-    stream->write((uint64_t*)&cgen_var_532, 1 * 8);
+    uint64_t cgen_var_540;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_540, 1);
+    stream->write((uint64_t*)&cgen_var_540, 1 * 8);
     stream->write((uint32_t*)&local_indexCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_firstIndex, sizeof(uint32_t));
@@ -7258,12 +7357,12 @@
     local_stride = stride;
     countingStream->rewind();
     {
-        uint64_t cgen_var_533;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_533, 1);
-        countingStream->write((uint64_t*)&cgen_var_533, 1 * 8);
-        uint64_t cgen_var_534;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_534, 1);
-        countingStream->write((uint64_t*)&cgen_var_534, 1 * 8);
+        uint64_t cgen_var_541;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_541, 1);
+        countingStream->write((uint64_t*)&cgen_var_541, 1 * 8);
+        uint64_t cgen_var_542;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_542, 1);
+        countingStream->write((uint64_t*)&cgen_var_542, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
         countingStream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -7273,12 +7372,12 @@
     uint32_t opcode_vkCmdDrawIndirect = OP_vkCmdDrawIndirect;
     stream->write(&opcode_vkCmdDrawIndirect, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDrawIndirect, sizeof(uint32_t));
-    uint64_t cgen_var_535;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_535, 1);
-    stream->write((uint64_t*)&cgen_var_535, 1 * 8);
-    uint64_t cgen_var_536;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_536, 1);
-    stream->write((uint64_t*)&cgen_var_536, 1 * 8);
+    uint64_t cgen_var_543;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_543, 1);
+    stream->write((uint64_t*)&cgen_var_543, 1 * 8);
+    uint64_t cgen_var_544;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_544, 1);
+    stream->write((uint64_t*)&cgen_var_544, 1 * 8);
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -7310,12 +7409,12 @@
     local_stride = stride;
     countingStream->rewind();
     {
-        uint64_t cgen_var_537;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_537, 1);
-        countingStream->write((uint64_t*)&cgen_var_537, 1 * 8);
-        uint64_t cgen_var_538;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_538, 1);
-        countingStream->write((uint64_t*)&cgen_var_538, 1 * 8);
+        uint64_t cgen_var_545;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_545, 1);
+        countingStream->write((uint64_t*)&cgen_var_545, 1 * 8);
+        uint64_t cgen_var_546;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_546, 1);
+        countingStream->write((uint64_t*)&cgen_var_546, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
         countingStream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -7325,12 +7424,12 @@
     uint32_t opcode_vkCmdDrawIndexedIndirect = OP_vkCmdDrawIndexedIndirect;
     stream->write(&opcode_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
-    uint64_t cgen_var_539;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_539, 1);
-    stream->write((uint64_t*)&cgen_var_539, 1 * 8);
-    uint64_t cgen_var_540;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_540, 1);
-    stream->write((uint64_t*)&cgen_var_540, 1 * 8);
+    uint64_t cgen_var_547;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_547, 1);
+    stream->write((uint64_t*)&cgen_var_547, 1 * 8);
+    uint64_t cgen_var_548;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_548, 1);
+    stream->write((uint64_t*)&cgen_var_548, 1 * 8);
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -7359,9 +7458,9 @@
     local_groupCountZ = groupCountZ;
     countingStream->rewind();
     {
-        uint64_t cgen_var_541;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_541, 1);
-        countingStream->write((uint64_t*)&cgen_var_541, 1 * 8);
+        uint64_t cgen_var_549;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_549, 1);
+        countingStream->write((uint64_t*)&cgen_var_549, 1 * 8);
         countingStream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
@@ -7371,9 +7470,9 @@
     uint32_t opcode_vkCmdDispatch = OP_vkCmdDispatch;
     stream->write(&opcode_vkCmdDispatch, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDispatch, sizeof(uint32_t));
-    uint64_t cgen_var_542;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_542, 1);
-    stream->write((uint64_t*)&cgen_var_542, 1 * 8);
+    uint64_t cgen_var_550;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_550, 1);
+    stream->write((uint64_t*)&cgen_var_550, 1 * 8);
     stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
     stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
     stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
@@ -7399,12 +7498,12 @@
     local_offset = offset;
     countingStream->rewind();
     {
-        uint64_t cgen_var_543;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_543, 1);
-        countingStream->write((uint64_t*)&cgen_var_543, 1 * 8);
-        uint64_t cgen_var_544;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_544, 1);
-        countingStream->write((uint64_t*)&cgen_var_544, 1 * 8);
+        uint64_t cgen_var_551;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_551, 1);
+        countingStream->write((uint64_t*)&cgen_var_551, 1 * 8);
+        uint64_t cgen_var_552;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_552, 1);
+        countingStream->write((uint64_t*)&cgen_var_552, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
     }
     uint32_t packetSize_vkCmdDispatchIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -7412,12 +7511,12 @@
     uint32_t opcode_vkCmdDispatchIndirect = OP_vkCmdDispatchIndirect;
     stream->write(&opcode_vkCmdDispatchIndirect, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDispatchIndirect, sizeof(uint32_t));
-    uint64_t cgen_var_545;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_545, 1);
-    stream->write((uint64_t*)&cgen_var_545, 1 * 8);
-    uint64_t cgen_var_546;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_546, 1);
-    stream->write((uint64_t*)&cgen_var_546, 1 * 8);
+    uint64_t cgen_var_553;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_553, 1);
+    stream->write((uint64_t*)&cgen_var_553, 1 * 8);
+    uint64_t cgen_var_554;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_554, 1);
+    stream->write((uint64_t*)&cgen_var_554, 1 * 8);
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
     mImpl->log("finish vkCmdDispatchIndirect");;
 }
@@ -7462,15 +7561,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_547;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_547, 1);
-        countingStream->write((uint64_t*)&cgen_var_547, 1 * 8);
-        uint64_t cgen_var_548;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_548, 1);
-        countingStream->write((uint64_t*)&cgen_var_548, 1 * 8);
-        uint64_t cgen_var_549;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_549, 1);
-        countingStream->write((uint64_t*)&cgen_var_549, 1 * 8);
+        uint64_t cgen_var_555;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_555, 1);
+        countingStream->write((uint64_t*)&cgen_var_555, 1 * 8);
+        uint64_t cgen_var_556;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_556, 1);
+        countingStream->write((uint64_t*)&cgen_var_556, 1 * 8);
+        uint64_t cgen_var_557;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_557, 1);
+        countingStream->write((uint64_t*)&cgen_var_557, 1 * 8);
         countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
         {
@@ -7482,15 +7581,15 @@
     uint32_t opcode_vkCmdCopyBuffer = OP_vkCmdCopyBuffer;
     stream->write(&opcode_vkCmdCopyBuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdCopyBuffer, sizeof(uint32_t));
-    uint64_t cgen_var_550;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_550, 1);
-    stream->write((uint64_t*)&cgen_var_550, 1 * 8);
-    uint64_t cgen_var_551;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_551, 1);
-    stream->write((uint64_t*)&cgen_var_551, 1 * 8);
-    uint64_t cgen_var_552;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_552, 1);
-    stream->write((uint64_t*)&cgen_var_552, 1 * 8);
+    uint64_t cgen_var_558;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_558, 1);
+    stream->write((uint64_t*)&cgen_var_558, 1 * 8);
+    uint64_t cgen_var_559;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_559, 1);
+    stream->write((uint64_t*)&cgen_var_559, 1 * 8);
+    uint64_t cgen_var_560;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_560, 1);
+    stream->write((uint64_t*)&cgen_var_560, 1 * 8);
     stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
     {
@@ -7545,16 +7644,16 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_553;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_553, 1);
-        countingStream->write((uint64_t*)&cgen_var_553, 1 * 8);
-        uint64_t cgen_var_554;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_554, 1);
-        countingStream->write((uint64_t*)&cgen_var_554, 1 * 8);
+        uint64_t cgen_var_561;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_561, 1);
+        countingStream->write((uint64_t*)&cgen_var_561, 1 * 8);
+        uint64_t cgen_var_562;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_562, 1);
+        countingStream->write((uint64_t*)&cgen_var_562, 1 * 8);
         countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
-        uint64_t cgen_var_555;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_555, 1);
-        countingStream->write((uint64_t*)&cgen_var_555, 1 * 8);
+        uint64_t cgen_var_563;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_563, 1);
+        countingStream->write((uint64_t*)&cgen_var_563, 1 * 8);
         countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
         countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -7567,16 +7666,16 @@
     uint32_t opcode_vkCmdCopyImage = OP_vkCmdCopyImage;
     stream->write(&opcode_vkCmdCopyImage, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdCopyImage, sizeof(uint32_t));
-    uint64_t cgen_var_556;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_556, 1);
-    stream->write((uint64_t*)&cgen_var_556, 1 * 8);
-    uint64_t cgen_var_557;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_557, 1);
-    stream->write((uint64_t*)&cgen_var_557, 1 * 8);
+    uint64_t cgen_var_564;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_564, 1);
+    stream->write((uint64_t*)&cgen_var_564, 1 * 8);
+    uint64_t cgen_var_565;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_565, 1);
+    stream->write((uint64_t*)&cgen_var_565, 1 * 8);
     stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_558;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_558, 1);
-    stream->write((uint64_t*)&cgen_var_558, 1 * 8);
+    uint64_t cgen_var_566;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_566, 1);
+    stream->write((uint64_t*)&cgen_var_566, 1 * 8);
     stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
     stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -7635,16 +7734,16 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_559;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_559, 1);
-        countingStream->write((uint64_t*)&cgen_var_559, 1 * 8);
-        uint64_t cgen_var_560;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_560, 1);
-        countingStream->write((uint64_t*)&cgen_var_560, 1 * 8);
+        uint64_t cgen_var_567;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_567, 1);
+        countingStream->write((uint64_t*)&cgen_var_567, 1 * 8);
+        uint64_t cgen_var_568;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_568, 1);
+        countingStream->write((uint64_t*)&cgen_var_568, 1 * 8);
         countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
-        uint64_t cgen_var_561;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_561, 1);
-        countingStream->write((uint64_t*)&cgen_var_561, 1 * 8);
+        uint64_t cgen_var_569;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_569, 1);
+        countingStream->write((uint64_t*)&cgen_var_569, 1 * 8);
         countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
         countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -7658,16 +7757,16 @@
     uint32_t opcode_vkCmdBlitImage = OP_vkCmdBlitImage;
     stream->write(&opcode_vkCmdBlitImage, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdBlitImage, sizeof(uint32_t));
-    uint64_t cgen_var_562;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_562, 1);
-    stream->write((uint64_t*)&cgen_var_562, 1 * 8);
-    uint64_t cgen_var_563;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_563, 1);
-    stream->write((uint64_t*)&cgen_var_563, 1 * 8);
+    uint64_t cgen_var_570;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_570, 1);
+    stream->write((uint64_t*)&cgen_var_570, 1 * 8);
+    uint64_t cgen_var_571;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_571, 1);
+    stream->write((uint64_t*)&cgen_var_571, 1 * 8);
     stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_564;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_564, 1);
-    stream->write((uint64_t*)&cgen_var_564, 1 * 8);
+    uint64_t cgen_var_572;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_572, 1);
+    stream->write((uint64_t*)&cgen_var_572, 1 * 8);
     stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
     stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -7721,15 +7820,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_565;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_565, 1);
-        countingStream->write((uint64_t*)&cgen_var_565, 1 * 8);
-        uint64_t cgen_var_566;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_566, 1);
-        countingStream->write((uint64_t*)&cgen_var_566, 1 * 8);
-        uint64_t cgen_var_567;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_567, 1);
-        countingStream->write((uint64_t*)&cgen_var_567, 1 * 8);
+        uint64_t cgen_var_573;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_573, 1);
+        countingStream->write((uint64_t*)&cgen_var_573, 1 * 8);
+        uint64_t cgen_var_574;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_574, 1);
+        countingStream->write((uint64_t*)&cgen_var_574, 1 * 8);
+        uint64_t cgen_var_575;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_575, 1);
+        countingStream->write((uint64_t*)&cgen_var_575, 1 * 8);
         countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
         countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -7742,15 +7841,15 @@
     uint32_t opcode_vkCmdCopyBufferToImage = OP_vkCmdCopyBufferToImage;
     stream->write(&opcode_vkCmdCopyBufferToImage, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdCopyBufferToImage, sizeof(uint32_t));
-    uint64_t cgen_var_568;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_568, 1);
-    stream->write((uint64_t*)&cgen_var_568, 1 * 8);
-    uint64_t cgen_var_569;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_569, 1);
-    stream->write((uint64_t*)&cgen_var_569, 1 * 8);
-    uint64_t cgen_var_570;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_570, 1);
-    stream->write((uint64_t*)&cgen_var_570, 1 * 8);
+    uint64_t cgen_var_576;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_576, 1);
+    stream->write((uint64_t*)&cgen_var_576, 1 * 8);
+    uint64_t cgen_var_577;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_577, 1);
+    stream->write((uint64_t*)&cgen_var_577, 1 * 8);
+    uint64_t cgen_var_578;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_578, 1);
+    stream->write((uint64_t*)&cgen_var_578, 1 * 8);
     stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
     stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -7803,16 +7902,16 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_571;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_571, 1);
-        countingStream->write((uint64_t*)&cgen_var_571, 1 * 8);
-        uint64_t cgen_var_572;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_572, 1);
-        countingStream->write((uint64_t*)&cgen_var_572, 1 * 8);
+        uint64_t cgen_var_579;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_579, 1);
+        countingStream->write((uint64_t*)&cgen_var_579, 1 * 8);
+        uint64_t cgen_var_580;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_580, 1);
+        countingStream->write((uint64_t*)&cgen_var_580, 1 * 8);
         countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
-        uint64_t cgen_var_573;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_573, 1);
-        countingStream->write((uint64_t*)&cgen_var_573, 1 * 8);
+        uint64_t cgen_var_581;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_581, 1);
+        countingStream->write((uint64_t*)&cgen_var_581, 1 * 8);
         countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
         {
@@ -7824,16 +7923,16 @@
     uint32_t opcode_vkCmdCopyImageToBuffer = OP_vkCmdCopyImageToBuffer;
     stream->write(&opcode_vkCmdCopyImageToBuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdCopyImageToBuffer, sizeof(uint32_t));
-    uint64_t cgen_var_574;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_574, 1);
-    stream->write((uint64_t*)&cgen_var_574, 1 * 8);
-    uint64_t cgen_var_575;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_575, 1);
-    stream->write((uint64_t*)&cgen_var_575, 1 * 8);
+    uint64_t cgen_var_582;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_582, 1);
+    stream->write((uint64_t*)&cgen_var_582, 1 * 8);
+    uint64_t cgen_var_583;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_583, 1);
+    stream->write((uint64_t*)&cgen_var_583, 1 * 8);
     stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_576;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_576, 1);
-    stream->write((uint64_t*)&cgen_var_576, 1 * 8);
+    uint64_t cgen_var_584;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_584, 1);
+    stream->write((uint64_t*)&cgen_var_584, 1 * 8);
     stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
     {
@@ -7871,12 +7970,12 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_577;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_577, 1);
-        countingStream->write((uint64_t*)&cgen_var_577, 1 * 8);
-        uint64_t cgen_var_578;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_578, 1);
-        countingStream->write((uint64_t*)&cgen_var_578, 1 * 8);
+        uint64_t cgen_var_585;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_585, 1);
+        countingStream->write((uint64_t*)&cgen_var_585, 1 * 8);
+        uint64_t cgen_var_586;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_586, 1);
+        countingStream->write((uint64_t*)&cgen_var_586, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
         countingStream->write((VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
         countingStream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t));
@@ -7886,12 +7985,12 @@
     uint32_t opcode_vkCmdUpdateBuffer = OP_vkCmdUpdateBuffer;
     stream->write(&opcode_vkCmdUpdateBuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdUpdateBuffer, sizeof(uint32_t));
-    uint64_t cgen_var_579;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_579, 1);
-    stream->write((uint64_t*)&cgen_var_579, 1 * 8);
-    uint64_t cgen_var_580;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_580, 1);
-    stream->write((uint64_t*)&cgen_var_580, 1 * 8);
+    uint64_t cgen_var_587;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_587, 1);
+    stream->write((uint64_t*)&cgen_var_587, 1 * 8);
+    uint64_t cgen_var_588;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_588, 1);
+    stream->write((uint64_t*)&cgen_var_588, 1 * 8);
     stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
     stream->write((VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
     stream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t));
@@ -7923,12 +8022,12 @@
     local_data = data;
     countingStream->rewind();
     {
-        uint64_t cgen_var_581;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_581, 1);
-        countingStream->write((uint64_t*)&cgen_var_581, 1 * 8);
-        uint64_t cgen_var_582;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_582, 1);
-        countingStream->write((uint64_t*)&cgen_var_582, 1 * 8);
+        uint64_t cgen_var_589;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_589, 1);
+        countingStream->write((uint64_t*)&cgen_var_589, 1 * 8);
+        uint64_t cgen_var_590;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_590, 1);
+        countingStream->write((uint64_t*)&cgen_var_590, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
         countingStream->write((VkDeviceSize*)&local_size, sizeof(VkDeviceSize));
         countingStream->write((uint32_t*)&local_data, sizeof(uint32_t));
@@ -7938,12 +8037,12 @@
     uint32_t opcode_vkCmdFillBuffer = OP_vkCmdFillBuffer;
     stream->write(&opcode_vkCmdFillBuffer, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdFillBuffer, sizeof(uint32_t));
-    uint64_t cgen_var_583;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_583, 1);
-    stream->write((uint64_t*)&cgen_var_583, 1 * 8);
-    uint64_t cgen_var_584;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_584, 1);
-    stream->write((uint64_t*)&cgen_var_584, 1 * 8);
+    uint64_t cgen_var_591;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_591, 1);
+    stream->write((uint64_t*)&cgen_var_591, 1 * 8);
+    uint64_t cgen_var_592;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_592, 1);
+    stream->write((uint64_t*)&cgen_var_592, 1 * 8);
     stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
     stream->write((VkDeviceSize*)&local_size, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_data, sizeof(uint32_t));
@@ -8002,12 +8101,12 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_585;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_585, 1);
-        countingStream->write((uint64_t*)&cgen_var_585, 1 * 8);
-        uint64_t cgen_var_586;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_586, 1);
-        countingStream->write((uint64_t*)&cgen_var_586, 1 * 8);
+        uint64_t cgen_var_593;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_593, 1);
+        countingStream->write((uint64_t*)&cgen_var_593, 1 * 8);
+        uint64_t cgen_var_594;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_594, 1);
+        countingStream->write((uint64_t*)&cgen_var_594, 1 * 8);
         countingStream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
         marshal_VkClearColorValue(countingStream, (VkClearColorValue*)(local_pColor));
         countingStream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
@@ -8021,12 +8120,12 @@
     uint32_t opcode_vkCmdClearColorImage = OP_vkCmdClearColorImage;
     stream->write(&opcode_vkCmdClearColorImage, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdClearColorImage, sizeof(uint32_t));
-    uint64_t cgen_var_587;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_587, 1);
-    stream->write((uint64_t*)&cgen_var_587, 1 * 8);
-    uint64_t cgen_var_588;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_588, 1);
-    stream->write((uint64_t*)&cgen_var_588, 1 * 8);
+    uint64_t cgen_var_595;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_595, 1);
+    stream->write((uint64_t*)&cgen_var_595, 1 * 8);
+    uint64_t cgen_var_596;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_596, 1);
+    stream->write((uint64_t*)&cgen_var_596, 1 * 8);
     stream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
     marshal_VkClearColorValue(stream, (VkClearColorValue*)(local_pColor));
     stream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
@@ -8089,12 +8188,12 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_589;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_589, 1);
-        countingStream->write((uint64_t*)&cgen_var_589, 1 * 8);
-        uint64_t cgen_var_590;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_590, 1);
-        countingStream->write((uint64_t*)&cgen_var_590, 1 * 8);
+        uint64_t cgen_var_597;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_597, 1);
+        countingStream->write((uint64_t*)&cgen_var_597, 1 * 8);
+        uint64_t cgen_var_598;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_598, 1);
+        countingStream->write((uint64_t*)&cgen_var_598, 1 * 8);
         countingStream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
         marshal_VkClearDepthStencilValue(countingStream, (VkClearDepthStencilValue*)(local_pDepthStencil));
         countingStream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
@@ -8108,12 +8207,12 @@
     uint32_t opcode_vkCmdClearDepthStencilImage = OP_vkCmdClearDepthStencilImage;
     stream->write(&opcode_vkCmdClearDepthStencilImage, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdClearDepthStencilImage, sizeof(uint32_t));
-    uint64_t cgen_var_591;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_591, 1);
-    stream->write((uint64_t*)&cgen_var_591, 1 * 8);
-    uint64_t cgen_var_592;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_592, 1);
-    stream->write((uint64_t*)&cgen_var_592, 1 * 8);
+    uint64_t cgen_var_599;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_599, 1);
+    stream->write((uint64_t*)&cgen_var_599, 1 * 8);
+    uint64_t cgen_var_600;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_600, 1);
+    stream->write((uint64_t*)&cgen_var_600, 1 * 8);
     stream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
     marshal_VkClearDepthStencilValue(stream, (VkClearDepthStencilValue*)(local_pDepthStencil));
     stream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
@@ -8179,9 +8278,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_593;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_593, 1);
-        countingStream->write((uint64_t*)&cgen_var_593, 1 * 8);
+        uint64_t cgen_var_601;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_601, 1);
+        countingStream->write((uint64_t*)&cgen_var_601, 1 * 8);
         countingStream->write((uint32_t*)&local_attachmentCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
         {
@@ -8198,9 +8297,9 @@
     uint32_t opcode_vkCmdClearAttachments = OP_vkCmdClearAttachments;
     stream->write(&opcode_vkCmdClearAttachments, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdClearAttachments, sizeof(uint32_t));
-    uint64_t cgen_var_594;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_594, 1);
-    stream->write((uint64_t*)&cgen_var_594, 1 * 8);
+    uint64_t cgen_var_602;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_602, 1);
+    stream->write((uint64_t*)&cgen_var_602, 1 * 8);
     stream->write((uint32_t*)&local_attachmentCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
     {
@@ -8260,16 +8359,16 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_595;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_595, 1);
-        countingStream->write((uint64_t*)&cgen_var_595, 1 * 8);
-        uint64_t cgen_var_596;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_596, 1);
-        countingStream->write((uint64_t*)&cgen_var_596, 1 * 8);
+        uint64_t cgen_var_603;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_603, 1);
+        countingStream->write((uint64_t*)&cgen_var_603, 1 * 8);
+        uint64_t cgen_var_604;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_604, 1);
+        countingStream->write((uint64_t*)&cgen_var_604, 1 * 8);
         countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
-        uint64_t cgen_var_597;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_597, 1);
-        countingStream->write((uint64_t*)&cgen_var_597, 1 * 8);
+        uint64_t cgen_var_605;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_605, 1);
+        countingStream->write((uint64_t*)&cgen_var_605, 1 * 8);
         countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
         countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -8282,16 +8381,16 @@
     uint32_t opcode_vkCmdResolveImage = OP_vkCmdResolveImage;
     stream->write(&opcode_vkCmdResolveImage, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdResolveImage, sizeof(uint32_t));
-    uint64_t cgen_var_598;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_598, 1);
-    stream->write((uint64_t*)&cgen_var_598, 1 * 8);
-    uint64_t cgen_var_599;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_599, 1);
-    stream->write((uint64_t*)&cgen_var_599, 1 * 8);
+    uint64_t cgen_var_606;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_606, 1);
+    stream->write((uint64_t*)&cgen_var_606, 1 * 8);
+    uint64_t cgen_var_607;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_607, 1);
+    stream->write((uint64_t*)&cgen_var_607, 1 * 8);
     stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_600;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_600, 1);
-    stream->write((uint64_t*)&cgen_var_600, 1 * 8);
+    uint64_t cgen_var_608;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_608, 1);
+    stream->write((uint64_t*)&cgen_var_608, 1 * 8);
     stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
     stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -8320,12 +8419,12 @@
     local_stageMask = stageMask;
     countingStream->rewind();
     {
-        uint64_t cgen_var_601;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_601, 1);
-        countingStream->write((uint64_t*)&cgen_var_601, 1 * 8);
-        uint64_t cgen_var_602;
-        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_602, 1);
-        countingStream->write((uint64_t*)&cgen_var_602, 1 * 8);
+        uint64_t cgen_var_609;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_609, 1);
+        countingStream->write((uint64_t*)&cgen_var_609, 1 * 8);
+        uint64_t cgen_var_610;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_610, 1);
+        countingStream->write((uint64_t*)&cgen_var_610, 1 * 8);
         countingStream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
     }
     uint32_t packetSize_vkCmdSetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -8333,12 +8432,12 @@
     uint32_t opcode_vkCmdSetEvent = OP_vkCmdSetEvent;
     stream->write(&opcode_vkCmdSetEvent, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetEvent, sizeof(uint32_t));
-    uint64_t cgen_var_603;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_603, 1);
-    stream->write((uint64_t*)&cgen_var_603, 1 * 8);
-    uint64_t cgen_var_604;
-    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_604, 1);
-    stream->write((uint64_t*)&cgen_var_604, 1 * 8);
+    uint64_t cgen_var_611;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_611, 1);
+    stream->write((uint64_t*)&cgen_var_611, 1 * 8);
+    uint64_t cgen_var_612;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_612, 1);
+    stream->write((uint64_t*)&cgen_var_612, 1 * 8);
     stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
     mImpl->log("finish vkCmdSetEvent");;
 }
@@ -8362,12 +8461,12 @@
     local_stageMask = stageMask;
     countingStream->rewind();
     {
-        uint64_t cgen_var_605;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_605, 1);
-        countingStream->write((uint64_t*)&cgen_var_605, 1 * 8);
-        uint64_t cgen_var_606;
-        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_606, 1);
-        countingStream->write((uint64_t*)&cgen_var_606, 1 * 8);
+        uint64_t cgen_var_613;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_613, 1);
+        countingStream->write((uint64_t*)&cgen_var_613, 1 * 8);
+        uint64_t cgen_var_614;
+        countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_614, 1);
+        countingStream->write((uint64_t*)&cgen_var_614, 1 * 8);
         countingStream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
     }
     uint32_t packetSize_vkCmdResetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -8375,12 +8474,12 @@
     uint32_t opcode_vkCmdResetEvent = OP_vkCmdResetEvent;
     stream->write(&opcode_vkCmdResetEvent, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdResetEvent, sizeof(uint32_t));
-    uint64_t cgen_var_607;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_607, 1);
-    stream->write((uint64_t*)&cgen_var_607, 1 * 8);
-    uint64_t cgen_var_608;
-    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_608, 1);
-    stream->write((uint64_t*)&cgen_var_608, 1 * 8);
+    uint64_t cgen_var_615;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_615, 1);
+    stream->write((uint64_t*)&cgen_var_615, 1 * 8);
+    uint64_t cgen_var_616;
+    stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_616, 1);
+    stream->write((uint64_t*)&cgen_var_616, 1 * 8);
     stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
     mImpl->log("finish vkCmdResetEvent");;
 }
@@ -8477,16 +8576,16 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_609;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_609, 1);
-        countingStream->write((uint64_t*)&cgen_var_609, 1 * 8);
+        uint64_t cgen_var_617;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_617, 1);
+        countingStream->write((uint64_t*)&cgen_var_617, 1 * 8);
         countingStream->write((uint32_t*)&local_eventCount, sizeof(uint32_t));
         if (((eventCount)))
         {
-            uint64_t* cgen_var_610;
-            countingStream->alloc((void**)&cgen_var_610, ((eventCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_610, ((eventCount)));
-            countingStream->write((uint64_t*)cgen_var_610, ((eventCount)) * 8);
+            uint64_t* cgen_var_618;
+            countingStream->alloc((void**)&cgen_var_618, ((eventCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_618, ((eventCount)));
+            countingStream->write((uint64_t*)cgen_var_618, ((eventCount)) * 8);
         }
         countingStream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
         countingStream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
@@ -8511,16 +8610,16 @@
     uint32_t opcode_vkCmdWaitEvents = OP_vkCmdWaitEvents;
     stream->write(&opcode_vkCmdWaitEvents, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdWaitEvents, sizeof(uint32_t));
-    uint64_t cgen_var_611;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_611, 1);
-    stream->write((uint64_t*)&cgen_var_611, 1 * 8);
+    uint64_t cgen_var_619;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_619, 1);
+    stream->write((uint64_t*)&cgen_var_619, 1 * 8);
     stream->write((uint32_t*)&local_eventCount, sizeof(uint32_t));
     if (((eventCount)))
     {
-        uint64_t* cgen_var_612;
-        stream->alloc((void**)&cgen_var_612, ((eventCount)) * 8);
-        stream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_612, ((eventCount)));
-        stream->write((uint64_t*)cgen_var_612, ((eventCount)) * 8);
+        uint64_t* cgen_var_620;
+        stream->alloc((void**)&cgen_var_620, ((eventCount)) * 8);
+        stream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_620, ((eventCount)));
+        stream->write((uint64_t*)cgen_var_620, ((eventCount)) * 8);
     }
     stream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
     stream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
@@ -8627,9 +8726,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_613;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_613, 1);
-        countingStream->write((uint64_t*)&cgen_var_613, 1 * 8);
+        uint64_t cgen_var_621;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_621, 1);
+        countingStream->write((uint64_t*)&cgen_var_621, 1 * 8);
         countingStream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
         countingStream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
         countingStream->write((VkDependencyFlags*)&local_dependencyFlags, sizeof(VkDependencyFlags));
@@ -8654,9 +8753,9 @@
     uint32_t opcode_vkCmdPipelineBarrier = OP_vkCmdPipelineBarrier;
     stream->write(&opcode_vkCmdPipelineBarrier, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdPipelineBarrier, sizeof(uint32_t));
-    uint64_t cgen_var_614;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_614, 1);
-    stream->write((uint64_t*)&cgen_var_614, 1 * 8);
+    uint64_t cgen_var_622;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_622, 1);
+    stream->write((uint64_t*)&cgen_var_622, 1 * 8);
     stream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
     stream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
     stream->write((VkDependencyFlags*)&local_dependencyFlags, sizeof(VkDependencyFlags));
@@ -8700,12 +8799,12 @@
     local_flags = flags;
     countingStream->rewind();
     {
-        uint64_t cgen_var_615;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_615, 1);
-        countingStream->write((uint64_t*)&cgen_var_615, 1 * 8);
-        uint64_t cgen_var_616;
-        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_616, 1);
-        countingStream->write((uint64_t*)&cgen_var_616, 1 * 8);
+        uint64_t cgen_var_623;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_623, 1);
+        countingStream->write((uint64_t*)&cgen_var_623, 1 * 8);
+        uint64_t cgen_var_624;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_624, 1);
+        countingStream->write((uint64_t*)&cgen_var_624, 1 * 8);
         countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
         countingStream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
     }
@@ -8714,12 +8813,12 @@
     uint32_t opcode_vkCmdBeginQuery = OP_vkCmdBeginQuery;
     stream->write(&opcode_vkCmdBeginQuery, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdBeginQuery, sizeof(uint32_t));
-    uint64_t cgen_var_617;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_617, 1);
-    stream->write((uint64_t*)&cgen_var_617, 1 * 8);
-    uint64_t cgen_var_618;
-    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_618, 1);
-    stream->write((uint64_t*)&cgen_var_618, 1 * 8);
+    uint64_t cgen_var_625;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_625, 1);
+    stream->write((uint64_t*)&cgen_var_625, 1 * 8);
+    uint64_t cgen_var_626;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_626, 1);
+    stream->write((uint64_t*)&cgen_var_626, 1 * 8);
     stream->write((uint32_t*)&local_query, sizeof(uint32_t));
     stream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
     mImpl->log("finish vkCmdBeginQuery");;
@@ -8744,12 +8843,12 @@
     local_query = query;
     countingStream->rewind();
     {
-        uint64_t cgen_var_619;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_619, 1);
-        countingStream->write((uint64_t*)&cgen_var_619, 1 * 8);
-        uint64_t cgen_var_620;
-        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_620, 1);
-        countingStream->write((uint64_t*)&cgen_var_620, 1 * 8);
+        uint64_t cgen_var_627;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_627, 1);
+        countingStream->write((uint64_t*)&cgen_var_627, 1 * 8);
+        uint64_t cgen_var_628;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_628, 1);
+        countingStream->write((uint64_t*)&cgen_var_628, 1 * 8);
         countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
     }
     uint32_t packetSize_vkCmdEndQuery = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -8757,12 +8856,12 @@
     uint32_t opcode_vkCmdEndQuery = OP_vkCmdEndQuery;
     stream->write(&opcode_vkCmdEndQuery, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdEndQuery, sizeof(uint32_t));
-    uint64_t cgen_var_621;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_621, 1);
-    stream->write((uint64_t*)&cgen_var_621, 1 * 8);
-    uint64_t cgen_var_622;
-    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_622, 1);
-    stream->write((uint64_t*)&cgen_var_622, 1 * 8);
+    uint64_t cgen_var_629;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_629, 1);
+    stream->write((uint64_t*)&cgen_var_629, 1 * 8);
+    uint64_t cgen_var_630;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_630, 1);
+    stream->write((uint64_t*)&cgen_var_630, 1 * 8);
     stream->write((uint32_t*)&local_query, sizeof(uint32_t));
     mImpl->log("finish vkCmdEndQuery");;
 }
@@ -8789,12 +8888,12 @@
     local_queryCount = queryCount;
     countingStream->rewind();
     {
-        uint64_t cgen_var_623;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_623, 1);
-        countingStream->write((uint64_t*)&cgen_var_623, 1 * 8);
-        uint64_t cgen_var_624;
-        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_624, 1);
-        countingStream->write((uint64_t*)&cgen_var_624, 1 * 8);
+        uint64_t cgen_var_631;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_631, 1);
+        countingStream->write((uint64_t*)&cgen_var_631, 1 * 8);
+        uint64_t cgen_var_632;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_632, 1);
+        countingStream->write((uint64_t*)&cgen_var_632, 1 * 8);
         countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
     }
@@ -8803,12 +8902,12 @@
     uint32_t opcode_vkCmdResetQueryPool = OP_vkCmdResetQueryPool;
     stream->write(&opcode_vkCmdResetQueryPool, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdResetQueryPool, sizeof(uint32_t));
-    uint64_t cgen_var_625;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_625, 1);
-    stream->write((uint64_t*)&cgen_var_625, 1 * 8);
-    uint64_t cgen_var_626;
-    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_626, 1);
-    stream->write((uint64_t*)&cgen_var_626, 1 * 8);
+    uint64_t cgen_var_633;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_633, 1);
+    stream->write((uint64_t*)&cgen_var_633, 1 * 8);
+    uint64_t cgen_var_634;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_634, 1);
+    stream->write((uint64_t*)&cgen_var_634, 1 * 8);
     stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
     stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
     mImpl->log("finish vkCmdResetQueryPool");;
@@ -8836,13 +8935,13 @@
     local_query = query;
     countingStream->rewind();
     {
-        uint64_t cgen_var_627;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_627, 1);
-        countingStream->write((uint64_t*)&cgen_var_627, 1 * 8);
+        uint64_t cgen_var_635;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_635, 1);
+        countingStream->write((uint64_t*)&cgen_var_635, 1 * 8);
         countingStream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
-        uint64_t cgen_var_628;
-        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_628, 1);
-        countingStream->write((uint64_t*)&cgen_var_628, 1 * 8);
+        uint64_t cgen_var_636;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_636, 1);
+        countingStream->write((uint64_t*)&cgen_var_636, 1 * 8);
         countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
     }
     uint32_t packetSize_vkCmdWriteTimestamp = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -8850,13 +8949,13 @@
     uint32_t opcode_vkCmdWriteTimestamp = OP_vkCmdWriteTimestamp;
     stream->write(&opcode_vkCmdWriteTimestamp, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdWriteTimestamp, sizeof(uint32_t));
-    uint64_t cgen_var_629;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_629, 1);
-    stream->write((uint64_t*)&cgen_var_629, 1 * 8);
+    uint64_t cgen_var_637;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_637, 1);
+    stream->write((uint64_t*)&cgen_var_637, 1 * 8);
     stream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
-    uint64_t cgen_var_630;
-    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_630, 1);
-    stream->write((uint64_t*)&cgen_var_630, 1 * 8);
+    uint64_t cgen_var_638;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_638, 1);
+    stream->write((uint64_t*)&cgen_var_638, 1 * 8);
     stream->write((uint32_t*)&local_query, sizeof(uint32_t));
     mImpl->log("finish vkCmdWriteTimestamp");;
 }
@@ -8895,17 +8994,17 @@
     local_flags = flags;
     countingStream->rewind();
     {
-        uint64_t cgen_var_631;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_631, 1);
-        countingStream->write((uint64_t*)&cgen_var_631, 1 * 8);
-        uint64_t cgen_var_632;
-        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_632, 1);
-        countingStream->write((uint64_t*)&cgen_var_632, 1 * 8);
+        uint64_t cgen_var_639;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_639, 1);
+        countingStream->write((uint64_t*)&cgen_var_639, 1 * 8);
+        uint64_t cgen_var_640;
+        countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_640, 1);
+        countingStream->write((uint64_t*)&cgen_var_640, 1 * 8);
         countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
-        uint64_t cgen_var_633;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_633, 1);
-        countingStream->write((uint64_t*)&cgen_var_633, 1 * 8);
+        uint64_t cgen_var_641;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_641, 1);
+        countingStream->write((uint64_t*)&cgen_var_641, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
         countingStream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
         countingStream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
@@ -8915,17 +9014,17 @@
     uint32_t opcode_vkCmdCopyQueryPoolResults = OP_vkCmdCopyQueryPoolResults;
     stream->write(&opcode_vkCmdCopyQueryPoolResults, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdCopyQueryPoolResults, sizeof(uint32_t));
-    uint64_t cgen_var_634;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_634, 1);
-    stream->write((uint64_t*)&cgen_var_634, 1 * 8);
-    uint64_t cgen_var_635;
-    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_635, 1);
-    stream->write((uint64_t*)&cgen_var_635, 1 * 8);
+    uint64_t cgen_var_642;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_642, 1);
+    stream->write((uint64_t*)&cgen_var_642, 1 * 8);
+    uint64_t cgen_var_643;
+    stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_643, 1);
+    stream->write((uint64_t*)&cgen_var_643, 1 * 8);
     stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
     stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
-    uint64_t cgen_var_636;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_636, 1);
-    stream->write((uint64_t*)&cgen_var_636, 1 * 8);
+    uint64_t cgen_var_644;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_644, 1);
+    stream->write((uint64_t*)&cgen_var_644, 1 * 8);
     stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
     stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
     stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
@@ -8964,12 +9063,12 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_637;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_637, 1);
-        countingStream->write((uint64_t*)&cgen_var_637, 1 * 8);
-        uint64_t cgen_var_638;
-        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_638, 1);
-        countingStream->write((uint64_t*)&cgen_var_638, 1 * 8);
+        uint64_t cgen_var_645;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_645, 1);
+        countingStream->write((uint64_t*)&cgen_var_645, 1 * 8);
+        uint64_t cgen_var_646;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_646, 1);
+        countingStream->write((uint64_t*)&cgen_var_646, 1 * 8);
         countingStream->write((VkShaderStageFlags*)&local_stageFlags, sizeof(VkShaderStageFlags));
         countingStream->write((uint32_t*)&local_offset, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_size, sizeof(uint32_t));
@@ -8980,12 +9079,12 @@
     uint32_t opcode_vkCmdPushConstants = OP_vkCmdPushConstants;
     stream->write(&opcode_vkCmdPushConstants, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdPushConstants, sizeof(uint32_t));
-    uint64_t cgen_var_639;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_639, 1);
-    stream->write((uint64_t*)&cgen_var_639, 1 * 8);
-    uint64_t cgen_var_640;
-    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_640, 1);
-    stream->write((uint64_t*)&cgen_var_640, 1 * 8);
+    uint64_t cgen_var_647;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_647, 1);
+    stream->write((uint64_t*)&cgen_var_647, 1 * 8);
+    uint64_t cgen_var_648;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_648, 1);
+    stream->write((uint64_t*)&cgen_var_648, 1 * 8);
     stream->write((VkShaderStageFlags*)&local_stageFlags, sizeof(VkShaderStageFlags));
     stream->write((uint32_t*)&local_offset, sizeof(uint32_t));
     stream->write((uint32_t*)&local_size, sizeof(uint32_t));
@@ -9021,9 +9120,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_641;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_641, 1);
-        countingStream->write((uint64_t*)&cgen_var_641, 1 * 8);
+        uint64_t cgen_var_649;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_649, 1);
+        countingStream->write((uint64_t*)&cgen_var_649, 1 * 8);
         marshal_VkRenderPassBeginInfo(countingStream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
         countingStream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
     }
@@ -9032,9 +9131,9 @@
     uint32_t opcode_vkCmdBeginRenderPass = OP_vkCmdBeginRenderPass;
     stream->write(&opcode_vkCmdBeginRenderPass, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdBeginRenderPass, sizeof(uint32_t));
-    uint64_t cgen_var_642;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_642, 1);
-    stream->write((uint64_t*)&cgen_var_642, 1 * 8);
+    uint64_t cgen_var_650;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_650, 1);
+    stream->write((uint64_t*)&cgen_var_650, 1 * 8);
     marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
     stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
     mImpl->log("finish vkCmdBeginRenderPass");;
@@ -9056,9 +9155,9 @@
     local_contents = contents;
     countingStream->rewind();
     {
-        uint64_t cgen_var_643;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_643, 1);
-        countingStream->write((uint64_t*)&cgen_var_643, 1 * 8);
+        uint64_t cgen_var_651;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_651, 1);
+        countingStream->write((uint64_t*)&cgen_var_651, 1 * 8);
         countingStream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
     }
     uint32_t packetSize_vkCmdNextSubpass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -9066,9 +9165,9 @@
     uint32_t opcode_vkCmdNextSubpass = OP_vkCmdNextSubpass;
     stream->write(&opcode_vkCmdNextSubpass, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdNextSubpass, sizeof(uint32_t));
-    uint64_t cgen_var_644;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_644, 1);
-    stream->write((uint64_t*)&cgen_var_644, 1 * 8);
+    uint64_t cgen_var_652;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_652, 1);
+    stream->write((uint64_t*)&cgen_var_652, 1 * 8);
     stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
     mImpl->log("finish vkCmdNextSubpass");;
 }
@@ -9086,18 +9185,18 @@
     local_commandBuffer = commandBuffer;
     countingStream->rewind();
     {
-        uint64_t cgen_var_645;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_645, 1);
-        countingStream->write((uint64_t*)&cgen_var_645, 1 * 8);
+        uint64_t cgen_var_653;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_653, 1);
+        countingStream->write((uint64_t*)&cgen_var_653, 1 * 8);
     }
     uint32_t packetSize_vkCmdEndRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCmdEndRenderPass = OP_vkCmdEndRenderPass;
     stream->write(&opcode_vkCmdEndRenderPass, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdEndRenderPass, sizeof(uint32_t));
-    uint64_t cgen_var_646;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_646, 1);
-    stream->write((uint64_t*)&cgen_var_646, 1 * 8);
+    uint64_t cgen_var_654;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_654, 1);
+    stream->write((uint64_t*)&cgen_var_654, 1 * 8);
     mImpl->log("finish vkCmdEndRenderPass");;
 }
 
@@ -9124,16 +9223,16 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_647;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_647, 1);
-        countingStream->write((uint64_t*)&cgen_var_647, 1 * 8);
+        uint64_t cgen_var_655;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_655, 1);
+        countingStream->write((uint64_t*)&cgen_var_655, 1 * 8);
         countingStream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
         if (((commandBufferCount)))
         {
-            uint64_t* cgen_var_648;
-            countingStream->alloc((void**)&cgen_var_648, ((commandBufferCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_648, ((commandBufferCount)));
-            countingStream->write((uint64_t*)cgen_var_648, ((commandBufferCount)) * 8);
+            uint64_t* cgen_var_656;
+            countingStream->alloc((void**)&cgen_var_656, ((commandBufferCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_656, ((commandBufferCount)));
+            countingStream->write((uint64_t*)cgen_var_656, ((commandBufferCount)) * 8);
         }
     }
     uint32_t packetSize_vkCmdExecuteCommands = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -9141,16 +9240,16 @@
     uint32_t opcode_vkCmdExecuteCommands = OP_vkCmdExecuteCommands;
     stream->write(&opcode_vkCmdExecuteCommands, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdExecuteCommands, sizeof(uint32_t));
-    uint64_t cgen_var_649;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_649, 1);
-    stream->write((uint64_t*)&cgen_var_649, 1 * 8);
+    uint64_t cgen_var_657;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_657, 1);
+    stream->write((uint64_t*)&cgen_var_657, 1 * 8);
     stream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
     if (((commandBufferCount)))
     {
-        uint64_t* cgen_var_650;
-        stream->alloc((void**)&cgen_var_650, ((commandBufferCount)) * 8);
-        stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_650, ((commandBufferCount)));
-        stream->write((uint64_t*)cgen_var_650, ((commandBufferCount)) * 8);
+        uint64_t* cgen_var_658;
+        stream->alloc((void**)&cgen_var_658, ((commandBufferCount)) * 8);
+        stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_658, ((commandBufferCount)));
+        stream->write((uint64_t*)cgen_var_658, ((commandBufferCount)) * 8);
     }
     mImpl->log("finish vkCmdExecuteCommands");;
 }
@@ -9200,9 +9299,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_651;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_651, 1);
-        countingStream->write((uint64_t*)&cgen_var_651, 1 * 8);
+        uint64_t cgen_var_659;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_659, 1);
+        countingStream->write((uint64_t*)&cgen_var_659, 1 * 8);
         countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
         {
@@ -9214,9 +9313,9 @@
     uint32_t opcode_vkBindBufferMemory2 = OP_vkBindBufferMemory2;
     stream->write(&opcode_vkBindBufferMemory2, sizeof(uint32_t));
     stream->write(&packetSize_vkBindBufferMemory2, sizeof(uint32_t));
-    uint64_t cgen_var_652;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_652, 1);
-    stream->write((uint64_t*)&cgen_var_652, 1 * 8);
+    uint64_t cgen_var_660;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_660, 1);
+    stream->write((uint64_t*)&cgen_var_660, 1 * 8);
     stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
     {
@@ -9265,9 +9364,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_653;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_653, 1);
-        countingStream->write((uint64_t*)&cgen_var_653, 1 * 8);
+        uint64_t cgen_var_661;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_661, 1);
+        countingStream->write((uint64_t*)&cgen_var_661, 1 * 8);
         countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
         {
@@ -9279,9 +9378,9 @@
     uint32_t opcode_vkBindImageMemory2 = OP_vkBindImageMemory2;
     stream->write(&opcode_vkBindImageMemory2, sizeof(uint32_t));
     stream->write(&packetSize_vkBindImageMemory2, sizeof(uint32_t));
-    uint64_t cgen_var_654;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_654, 1);
-    stream->write((uint64_t*)&cgen_var_654, 1 * 8);
+    uint64_t cgen_var_662;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_662, 1);
+    stream->write((uint64_t*)&cgen_var_662, 1 * 8);
     stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
     {
@@ -9319,9 +9418,9 @@
     local_remoteDeviceIndex = remoteDeviceIndex;
     countingStream->rewind();
     {
-        uint64_t cgen_var_655;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_655, 1);
-        countingStream->write((uint64_t*)&cgen_var_655, 1 * 8);
+        uint64_t cgen_var_663;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_663, 1);
+        countingStream->write((uint64_t*)&cgen_var_663, 1 * 8);
         countingStream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
@@ -9332,9 +9431,9 @@
     uint32_t opcode_vkGetDeviceGroupPeerMemoryFeatures = OP_vkGetDeviceGroupPeerMemoryFeatures;
     stream->write(&opcode_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
-    uint64_t cgen_var_656;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_656, 1);
-    stream->write((uint64_t*)&cgen_var_656, 1 * 8);
+    uint64_t cgen_var_664;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_664, 1);
+    stream->write((uint64_t*)&cgen_var_664, 1 * 8);
     stream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
     stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
     stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
@@ -9359,9 +9458,9 @@
     local_deviceMask = deviceMask;
     countingStream->rewind();
     {
-        uint64_t cgen_var_657;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_657, 1);
-        countingStream->write((uint64_t*)&cgen_var_657, 1 * 8);
+        uint64_t cgen_var_665;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_665, 1);
+        countingStream->write((uint64_t*)&cgen_var_665, 1 * 8);
         countingStream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
     }
     uint32_t packetSize_vkCmdSetDeviceMask = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -9369,9 +9468,9 @@
     uint32_t opcode_vkCmdSetDeviceMask = OP_vkCmdSetDeviceMask;
     stream->write(&opcode_vkCmdSetDeviceMask, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetDeviceMask, sizeof(uint32_t));
-    uint64_t cgen_var_658;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_658, 1);
-    stream->write((uint64_t*)&cgen_var_658, 1 * 8);
+    uint64_t cgen_var_666;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_666, 1);
+    stream->write((uint64_t*)&cgen_var_666, 1 * 8);
     stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
     mImpl->log("finish vkCmdSetDeviceMask");;
 }
@@ -9407,9 +9506,9 @@
     local_groupCountZ = groupCountZ;
     countingStream->rewind();
     {
-        uint64_t cgen_var_659;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_659, 1);
-        countingStream->write((uint64_t*)&cgen_var_659, 1 * 8);
+        uint64_t cgen_var_667;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_667, 1);
+        countingStream->write((uint64_t*)&cgen_var_667, 1 * 8);
         countingStream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
@@ -9422,9 +9521,9 @@
     uint32_t opcode_vkCmdDispatchBase = OP_vkCmdDispatchBase;
     stream->write(&opcode_vkCmdDispatchBase, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDispatchBase, sizeof(uint32_t));
-    uint64_t cgen_var_660;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_660, 1);
-    stream->write((uint64_t*)&cgen_var_660, 1 * 8);
+    uint64_t cgen_var_668;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_668, 1);
+    stream->write((uint64_t*)&cgen_var_668, 1 * 8);
     stream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
     stream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
     stream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
@@ -9449,19 +9548,19 @@
     local_instance = instance;
     countingStream->rewind();
     {
-        uint64_t cgen_var_661;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_661, 1);
-        countingStream->write((uint64_t*)&cgen_var_661, 1 * 8);
+        uint64_t cgen_var_669;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_669, 1);
+        countingStream->write((uint64_t*)&cgen_var_669, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_662 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
-        countingStream->putBe64(cgen_var_662);
+        uint64_t cgen_var_670 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+        countingStream->putBe64(cgen_var_670);
         if (pPhysicalDeviceGroupCount)
         {
             countingStream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_663 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
-        countingStream->putBe64(cgen_var_663);
+        uint64_t cgen_var_671 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+        countingStream->putBe64(cgen_var_671);
         if (pPhysicalDeviceGroupProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
@@ -9475,19 +9574,19 @@
     uint32_t opcode_vkEnumeratePhysicalDeviceGroups = OP_vkEnumeratePhysicalDeviceGroups;
     stream->write(&opcode_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
     stream->write(&packetSize_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
-    uint64_t cgen_var_664;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_664, 1);
-    stream->write((uint64_t*)&cgen_var_664, 1 * 8);
+    uint64_t cgen_var_672;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_672, 1);
+    stream->write((uint64_t*)&cgen_var_672, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_665 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
-    stream->putBe64(cgen_var_665);
+    uint64_t cgen_var_673 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+    stream->putBe64(cgen_var_673);
     if (pPhysicalDeviceGroupCount)
     {
         stream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_666 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
-    stream->putBe64(cgen_var_666);
+    uint64_t cgen_var_674 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+    stream->putBe64(cgen_var_674);
     if (pPhysicalDeviceGroupProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
@@ -9562,9 +9661,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_669;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_669, 1);
-        countingStream->write((uint64_t*)&cgen_var_669, 1 * 8);
+        uint64_t cgen_var_677;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_677, 1);
+        countingStream->write((uint64_t*)&cgen_var_677, 1 * 8);
         marshal_VkImageMemoryRequirementsInfo2(countingStream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
         marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
     }
@@ -9573,9 +9672,9 @@
     uint32_t opcode_vkGetImageMemoryRequirements2 = OP_vkGetImageMemoryRequirements2;
     stream->write(&opcode_vkGetImageMemoryRequirements2, sizeof(uint32_t));
     stream->write(&packetSize_vkGetImageMemoryRequirements2, sizeof(uint32_t));
-    uint64_t cgen_var_670;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_670, 1);
-    stream->write((uint64_t*)&cgen_var_670, 1 * 8);
+    uint64_t cgen_var_678;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_678, 1);
+    stream->write((uint64_t*)&cgen_var_678, 1 * 8);
     marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
     marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
     unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
@@ -9612,9 +9711,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_671;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_671, 1);
-        countingStream->write((uint64_t*)&cgen_var_671, 1 * 8);
+        uint64_t cgen_var_679;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_679, 1);
+        countingStream->write((uint64_t*)&cgen_var_679, 1 * 8);
         marshal_VkBufferMemoryRequirementsInfo2(countingStream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
         marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
     }
@@ -9623,9 +9722,9 @@
     uint32_t opcode_vkGetBufferMemoryRequirements2 = OP_vkGetBufferMemoryRequirements2;
     stream->write(&opcode_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
     stream->write(&packetSize_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
-    uint64_t cgen_var_672;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_672, 1);
-    stream->write((uint64_t*)&cgen_var_672, 1 * 8);
+    uint64_t cgen_var_680;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_680, 1);
+    stream->write((uint64_t*)&cgen_var_680, 1 * 8);
     marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
     marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
     unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
@@ -9663,20 +9762,20 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_673;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_673, 1);
-        countingStream->write((uint64_t*)&cgen_var_673, 1 * 8);
+        uint64_t cgen_var_681;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_681, 1);
+        countingStream->write((uint64_t*)&cgen_var_681, 1 * 8);
         marshal_VkImageSparseMemoryRequirementsInfo2(countingStream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_674 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
-        countingStream->putBe64(cgen_var_674);
+        uint64_t cgen_var_682 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+        countingStream->putBe64(cgen_var_682);
         if (pSparseMemoryRequirementCount)
         {
             countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_675 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
-        countingStream->putBe64(cgen_var_675);
+        uint64_t cgen_var_683 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+        countingStream->putBe64(cgen_var_683);
         if (pSparseMemoryRequirements)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -9690,20 +9789,20 @@
     uint32_t opcode_vkGetImageSparseMemoryRequirements2 = OP_vkGetImageSparseMemoryRequirements2;
     stream->write(&opcode_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
     stream->write(&packetSize_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
-    uint64_t cgen_var_676;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_676, 1);
-    stream->write((uint64_t*)&cgen_var_676, 1 * 8);
+    uint64_t cgen_var_684;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_684, 1);
+    stream->write((uint64_t*)&cgen_var_684, 1 * 8);
     marshal_VkImageSparseMemoryRequirementsInfo2(stream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_677 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
-    stream->putBe64(cgen_var_677);
+    uint64_t cgen_var_685 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+    stream->putBe64(cgen_var_685);
     if (pSparseMemoryRequirementCount)
     {
         stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_678 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
-    stream->putBe64(cgen_var_678);
+    uint64_t cgen_var_686 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+    stream->putBe64(cgen_var_686);
     if (pSparseMemoryRequirements)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -9760,9 +9859,9 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_681;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_681, 1);
-        countingStream->write((uint64_t*)&cgen_var_681, 1 * 8);
+        uint64_t cgen_var_689;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_689, 1);
+        countingStream->write((uint64_t*)&cgen_var_689, 1 * 8);
         marshal_VkPhysicalDeviceFeatures2(countingStream, (VkPhysicalDeviceFeatures2*)(pFeatures));
     }
     uint32_t packetSize_vkGetPhysicalDeviceFeatures2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -9770,9 +9869,9 @@
     uint32_t opcode_vkGetPhysicalDeviceFeatures2 = OP_vkGetPhysicalDeviceFeatures2;
     stream->write(&opcode_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
-    uint64_t cgen_var_682;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_682, 1);
-    stream->write((uint64_t*)&cgen_var_682, 1 * 8);
+    uint64_t cgen_var_690;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_690, 1);
+    stream->write((uint64_t*)&cgen_var_690, 1 * 8);
     marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
     unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
     if (pFeatures)
@@ -9786,7 +9885,36 @@
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceProperties2* pProperties)
 {
-    mImpl->resources()->on_vkGetPhysicalDeviceProperties2(this, physicalDevice, pProperties);
+    mImpl->log("start vkGetPhysicalDeviceProperties2");
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkPhysicalDevice local_physicalDevice;
+    local_physicalDevice = physicalDevice;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_691;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_691, 1);
+        countingStream->write((uint64_t*)&cgen_var_691, 1 * 8);
+        marshal_VkPhysicalDeviceProperties2(countingStream, (VkPhysicalDeviceProperties2*)(pProperties));
+    }
+    uint32_t packetSize_vkGetPhysicalDeviceProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetPhysicalDeviceProperties2 = OP_vkGetPhysicalDeviceProperties2;
+    stream->write(&opcode_vkGetPhysicalDeviceProperties2, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetPhysicalDeviceProperties2, sizeof(uint32_t));
+    uint64_t cgen_var_692;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_692, 1);
+    stream->write((uint64_t*)&cgen_var_692, 1 * 8);
+    marshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
+    unmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
+    if (pProperties)
+    {
+        transform_fromhost_VkPhysicalDeviceProperties2(mImpl->resources(), (VkPhysicalDeviceProperties2*)(pProperties));
+    }
+    mImpl->log("finish vkGetPhysicalDeviceProperties2");;
 }
 
 void VkEncoder::vkGetPhysicalDeviceFormatProperties2(
@@ -9806,9 +9934,9 @@
     local_format = format;
     countingStream->rewind();
     {
-        uint64_t cgen_var_683;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_683, 1);
-        countingStream->write((uint64_t*)&cgen_var_683, 1 * 8);
+        uint64_t cgen_var_693;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_693, 1);
+        countingStream->write((uint64_t*)&cgen_var_693, 1 * 8);
         countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
         marshal_VkFormatProperties2(countingStream, (VkFormatProperties2*)(pFormatProperties));
     }
@@ -9817,9 +9945,9 @@
     uint32_t opcode_vkGetPhysicalDeviceFormatProperties2 = OP_vkGetPhysicalDeviceFormatProperties2;
     stream->write(&opcode_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
-    uint64_t cgen_var_684;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_684, 1);
-    stream->write((uint64_t*)&cgen_var_684, 1 * 8);
+    uint64_t cgen_var_694;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_694, 1);
+    stream->write((uint64_t*)&cgen_var_694, 1 * 8);
     stream->write((VkFormat*)&local_format, sizeof(VkFormat));
     marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
     unmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
@@ -9856,9 +9984,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_685;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_685, 1);
-        countingStream->write((uint64_t*)&cgen_var_685, 1 * 8);
+        uint64_t cgen_var_695;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_695, 1);
+        countingStream->write((uint64_t*)&cgen_var_695, 1 * 8);
         marshal_VkPhysicalDeviceImageFormatInfo2(countingStream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
         marshal_VkImageFormatProperties2(countingStream, (VkImageFormatProperties2*)(pImageFormatProperties));
     }
@@ -9867,9 +9995,9 @@
     uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2 = OP_vkGetPhysicalDeviceImageFormatProperties2;
     stream->write(&opcode_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
-    uint64_t cgen_var_686;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_686, 1);
-    stream->write((uint64_t*)&cgen_var_686, 1 * 8);
+    uint64_t cgen_var_696;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_696, 1);
+    stream->write((uint64_t*)&cgen_var_696, 1 * 8);
     marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
     marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
     unmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
@@ -9901,19 +10029,19 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_687;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_687, 1);
-        countingStream->write((uint64_t*)&cgen_var_687, 1 * 8);
+        uint64_t cgen_var_697;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_697, 1);
+        countingStream->write((uint64_t*)&cgen_var_697, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_688 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
-        countingStream->putBe64(cgen_var_688);
+        uint64_t cgen_var_698 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+        countingStream->putBe64(cgen_var_698);
         if (pQueueFamilyPropertyCount)
         {
             countingStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_689 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
-        countingStream->putBe64(cgen_var_689);
+        uint64_t cgen_var_699 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+        countingStream->putBe64(cgen_var_699);
         if (pQueueFamilyProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
@@ -9927,19 +10055,19 @@
     uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2 = OP_vkGetPhysicalDeviceQueueFamilyProperties2;
     stream->write(&opcode_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
-    uint64_t cgen_var_690;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_690, 1);
-    stream->write((uint64_t*)&cgen_var_690, 1 * 8);
+    uint64_t cgen_var_700;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_700, 1);
+    stream->write((uint64_t*)&cgen_var_700, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_691 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
-    stream->putBe64(cgen_var_691);
+    uint64_t cgen_var_701 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+    stream->putBe64(cgen_var_701);
     if (pQueueFamilyPropertyCount)
     {
         stream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_692 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
-    stream->putBe64(cgen_var_692);
+    uint64_t cgen_var_702 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+    stream->putBe64(cgen_var_702);
     if (pQueueFamilyProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
@@ -9996,9 +10124,9 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_695;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_695, 1);
-        countingStream->write((uint64_t*)&cgen_var_695, 1 * 8);
+        uint64_t cgen_var_705;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_705, 1);
+        countingStream->write((uint64_t*)&cgen_var_705, 1 * 8);
         marshal_VkPhysicalDeviceMemoryProperties2(countingStream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     }
     uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -10006,15 +10134,16 @@
     uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2 = OP_vkGetPhysicalDeviceMemoryProperties2;
     stream->write(&opcode_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
-    uint64_t cgen_var_696;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_696, 1);
-    stream->write((uint64_t*)&cgen_var_696, 1 * 8);
+    uint64_t cgen_var_706;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_706, 1);
+    stream->write((uint64_t*)&cgen_var_706, 1 * 8);
     marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     if (pMemoryProperties)
     {
         transform_fromhost_VkPhysicalDeviceMemoryProperties2(mImpl->resources(), (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     }
+    mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties2(this, physicalDevice, pMemoryProperties);
     mImpl->log("finish vkGetPhysicalDeviceMemoryProperties2");;
 }
 
@@ -10045,20 +10174,20 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_697;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_697, 1);
-        countingStream->write((uint64_t*)&cgen_var_697, 1 * 8);
+        uint64_t cgen_var_707;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_707, 1);
+        countingStream->write((uint64_t*)&cgen_var_707, 1 * 8);
         marshal_VkPhysicalDeviceSparseImageFormatInfo2(countingStream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_698 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_698);
+        uint64_t cgen_var_708 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_708);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_699 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_699);
+        uint64_t cgen_var_709 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_709);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -10072,20 +10201,20 @@
     uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2 = OP_vkGetPhysicalDeviceSparseImageFormatProperties2;
     stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t));
-    uint64_t cgen_var_700;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_700, 1);
-    stream->write((uint64_t*)&cgen_var_700, 1 * 8);
+    uint64_t cgen_var_710;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_710, 1);
+    stream->write((uint64_t*)&cgen_var_710, 1 * 8);
     marshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_701 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_701);
+    uint64_t cgen_var_711 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_711);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_702 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_702);
+    uint64_t cgen_var_712 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_712);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -10147,12 +10276,12 @@
     local_flags = flags;
     countingStream->rewind();
     {
-        uint64_t cgen_var_705;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_705, 1);
-        countingStream->write((uint64_t*)&cgen_var_705, 1 * 8);
-        uint64_t cgen_var_706;
-        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_706, 1);
-        countingStream->write((uint64_t*)&cgen_var_706, 1 * 8);
+        uint64_t cgen_var_715;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_715, 1);
+        countingStream->write((uint64_t*)&cgen_var_715, 1 * 8);
+        uint64_t cgen_var_716;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_716, 1);
+        countingStream->write((uint64_t*)&cgen_var_716, 1 * 8);
         countingStream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
     }
     uint32_t packetSize_vkTrimCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -10160,12 +10289,12 @@
     uint32_t opcode_vkTrimCommandPool = OP_vkTrimCommandPool;
     stream->write(&opcode_vkTrimCommandPool, sizeof(uint32_t));
     stream->write(&packetSize_vkTrimCommandPool, sizeof(uint32_t));
-    uint64_t cgen_var_707;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_707, 1);
-    stream->write((uint64_t*)&cgen_var_707, 1 * 8);
-    uint64_t cgen_var_708;
-    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_708, 1);
-    stream->write((uint64_t*)&cgen_var_708, 1 * 8);
+    uint64_t cgen_var_717;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_717, 1);
+    stream->write((uint64_t*)&cgen_var_717, 1 * 8);
+    uint64_t cgen_var_718;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_718, 1);
+    stream->write((uint64_t*)&cgen_var_718, 1 * 8);
     stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
     mImpl->log("finish vkTrimCommandPool");;
 }
@@ -10196,31 +10325,31 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_709;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_709, 1);
-        countingStream->write((uint64_t*)&cgen_var_709, 1 * 8);
+        uint64_t cgen_var_719;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_719, 1);
+        countingStream->write((uint64_t*)&cgen_var_719, 1 * 8);
         marshal_VkDeviceQueueInfo2(countingStream, (VkDeviceQueueInfo2*)(local_pQueueInfo));
-        uint64_t cgen_var_710;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_710, 1);
-        countingStream->write((uint64_t*)&cgen_var_710, 8);
+        uint64_t cgen_var_720;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_720, 1);
+        countingStream->write((uint64_t*)&cgen_var_720, 8);
     }
     uint32_t packetSize_vkGetDeviceQueue2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkGetDeviceQueue2 = OP_vkGetDeviceQueue2;
     stream->write(&opcode_vkGetDeviceQueue2, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDeviceQueue2, sizeof(uint32_t));
-    uint64_t cgen_var_711;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_711, 1);
-    stream->write((uint64_t*)&cgen_var_711, 1 * 8);
+    uint64_t cgen_var_721;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_721, 1);
+    stream->write((uint64_t*)&cgen_var_721, 1 * 8);
     marshal_VkDeviceQueueInfo2(stream, (VkDeviceQueueInfo2*)(local_pQueueInfo));
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_712;
-    stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_712, 1);
-    stream->write((uint64_t*)&cgen_var_712, 8);
+    uint64_t cgen_var_722;
+    stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_722, 1);
+    stream->write((uint64_t*)&cgen_var_722, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_713;
-    stream->read((uint64_t*)&cgen_var_713, 8);
-    stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_713, (VkQueue*)pQueue, 1);
+    uint64_t cgen_var_723;
+    stream->read((uint64_t*)&cgen_var_723, 8);
+    stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_723, (VkQueue*)pQueue, 1);
     mImpl->log("finish vkGetDeviceQueue2");;
 }
 
@@ -10263,46 +10392,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_714;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_714, 1);
-        countingStream->write((uint64_t*)&cgen_var_714, 1 * 8);
+        uint64_t cgen_var_724;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_724, 1);
+        countingStream->write((uint64_t*)&cgen_var_724, 1 * 8);
         marshal_VkSamplerYcbcrConversionCreateInfo(countingStream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_715 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_715);
+        uint64_t cgen_var_725 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_725);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_716;
-        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_716, 1);
-        countingStream->write((uint64_t*)&cgen_var_716, 8);
+        uint64_t cgen_var_726;
+        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_726, 1);
+        countingStream->write((uint64_t*)&cgen_var_726, 8);
     }
     uint32_t packetSize_vkCreateSamplerYcbcrConversion = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateSamplerYcbcrConversion = OP_vkCreateSamplerYcbcrConversion;
     stream->write(&opcode_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
-    uint64_t cgen_var_717;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_717, 1);
-    stream->write((uint64_t*)&cgen_var_717, 1 * 8);
+    uint64_t cgen_var_727;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_727, 1);
+    stream->write((uint64_t*)&cgen_var_727, 1 * 8);
     marshal_VkSamplerYcbcrConversionCreateInfo(stream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_718 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_718);
+    uint64_t cgen_var_728 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_728);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_719;
-    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_719, 1);
-    stream->write((uint64_t*)&cgen_var_719, 8);
+    uint64_t cgen_var_729;
+    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_729, 1);
+    stream->write((uint64_t*)&cgen_var_729, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_720;
-    stream->read((uint64_t*)&cgen_var_720, 8);
-    stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_720, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
+    uint64_t cgen_var_730;
+    stream->read((uint64_t*)&cgen_var_730, 8);
+    stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_730, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSamplerYcbcrConversion_VkResult_return, sizeof(VkResult));
@@ -10342,15 +10471,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_721;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_721, 1);
-        countingStream->write((uint64_t*)&cgen_var_721, 1 * 8);
-        uint64_t cgen_var_722;
-        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_722, 1);
-        countingStream->write((uint64_t*)&cgen_var_722, 1 * 8);
+        uint64_t cgen_var_731;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_731, 1);
+        countingStream->write((uint64_t*)&cgen_var_731, 1 * 8);
+        uint64_t cgen_var_732;
+        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_732, 1);
+        countingStream->write((uint64_t*)&cgen_var_732, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_723 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_723);
+        uint64_t cgen_var_733 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_733);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -10361,15 +10490,15 @@
     uint32_t opcode_vkDestroySamplerYcbcrConversion = OP_vkDestroySamplerYcbcrConversion;
     stream->write(&opcode_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
-    uint64_t cgen_var_724;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_724, 1);
-    stream->write((uint64_t*)&cgen_var_724, 1 * 8);
-    uint64_t cgen_var_725;
-    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_725, 1);
-    stream->write((uint64_t*)&cgen_var_725, 1 * 8);
+    uint64_t cgen_var_734;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_734, 1);
+    stream->write((uint64_t*)&cgen_var_734, 1 * 8);
+    uint64_t cgen_var_735;
+    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_735, 1);
+    stream->write((uint64_t*)&cgen_var_735, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_726 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_726);
+    uint64_t cgen_var_736 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_736);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -10417,46 +10546,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_727;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_727, 1);
-        countingStream->write((uint64_t*)&cgen_var_727, 1 * 8);
+        uint64_t cgen_var_737;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_737, 1);
+        countingStream->write((uint64_t*)&cgen_var_737, 1 * 8);
         marshal_VkDescriptorUpdateTemplateCreateInfo(countingStream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_728 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_728);
+        uint64_t cgen_var_738 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_738);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_729;
-        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_729, 1);
-        countingStream->write((uint64_t*)&cgen_var_729, 8);
+        uint64_t cgen_var_739;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_739, 1);
+        countingStream->write((uint64_t*)&cgen_var_739, 8);
     }
     uint32_t packetSize_vkCreateDescriptorUpdateTemplate = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateDescriptorUpdateTemplate = OP_vkCreateDescriptorUpdateTemplate;
     stream->write(&opcode_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
-    uint64_t cgen_var_730;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_730, 1);
-    stream->write((uint64_t*)&cgen_var_730, 1 * 8);
+    uint64_t cgen_var_740;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_740, 1);
+    stream->write((uint64_t*)&cgen_var_740, 1 * 8);
     marshal_VkDescriptorUpdateTemplateCreateInfo(stream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_731 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_731);
+    uint64_t cgen_var_741 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_741);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_732;
-    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_732, 1);
-    stream->write((uint64_t*)&cgen_var_732, 8);
+    uint64_t cgen_var_742;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_742, 1);
+    stream->write((uint64_t*)&cgen_var_742, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_733;
-    stream->read((uint64_t*)&cgen_var_733, 8);
-    stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_733, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
+    uint64_t cgen_var_743;
+    stream->read((uint64_t*)&cgen_var_743, 8);
+    stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_743, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorUpdateTemplate_VkResult_return, sizeof(VkResult));
@@ -10496,15 +10625,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_734;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_734, 1);
-        countingStream->write((uint64_t*)&cgen_var_734, 1 * 8);
-        uint64_t cgen_var_735;
-        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_735, 1);
-        countingStream->write((uint64_t*)&cgen_var_735, 1 * 8);
+        uint64_t cgen_var_744;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_744, 1);
+        countingStream->write((uint64_t*)&cgen_var_744, 1 * 8);
+        uint64_t cgen_var_745;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_745, 1);
+        countingStream->write((uint64_t*)&cgen_var_745, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_736 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_736);
+        uint64_t cgen_var_746 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_746);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -10515,15 +10644,15 @@
     uint32_t opcode_vkDestroyDescriptorUpdateTemplate = OP_vkDestroyDescriptorUpdateTemplate;
     stream->write(&opcode_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
-    uint64_t cgen_var_737;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_737, 1);
-    stream->write((uint64_t*)&cgen_var_737, 1 * 8);
-    uint64_t cgen_var_738;
-    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_738, 1);
-    stream->write((uint64_t*)&cgen_var_738, 1 * 8);
+    uint64_t cgen_var_747;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_747, 1);
+    stream->write((uint64_t*)&cgen_var_747, 1 * 8);
+    uint64_t cgen_var_748;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_748, 1);
+    stream->write((uint64_t*)&cgen_var_748, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_739 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_739);
+    uint64_t cgen_var_749 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_749);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -10558,18 +10687,18 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_740;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_740, 1);
-        countingStream->write((uint64_t*)&cgen_var_740, 1 * 8);
-        uint64_t cgen_var_741;
-        countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_741, 1);
-        countingStream->write((uint64_t*)&cgen_var_741, 1 * 8);
-        uint64_t cgen_var_742;
-        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_742, 1);
-        countingStream->write((uint64_t*)&cgen_var_742, 1 * 8);
+        uint64_t cgen_var_750;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_750, 1);
+        countingStream->write((uint64_t*)&cgen_var_750, 1 * 8);
+        uint64_t cgen_var_751;
+        countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_751, 1);
+        countingStream->write((uint64_t*)&cgen_var_751, 1 * 8);
+        uint64_t cgen_var_752;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_752, 1);
+        countingStream->write((uint64_t*)&cgen_var_752, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_743 = (uint64_t)(uintptr_t)local_pData;
-        countingStream->putBe64(cgen_var_743);
+        uint64_t cgen_var_753 = (uint64_t)(uintptr_t)local_pData;
+        countingStream->putBe64(cgen_var_753);
         if (local_pData)
         {
             countingStream->write((void*)local_pData, sizeof(uint8_t));
@@ -10580,18 +10709,18 @@
     uint32_t opcode_vkUpdateDescriptorSetWithTemplate = OP_vkUpdateDescriptorSetWithTemplate;
     stream->write(&opcode_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
     stream->write(&packetSize_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
-    uint64_t cgen_var_744;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_744, 1);
-    stream->write((uint64_t*)&cgen_var_744, 1 * 8);
-    uint64_t cgen_var_745;
-    stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_745, 1);
-    stream->write((uint64_t*)&cgen_var_745, 1 * 8);
-    uint64_t cgen_var_746;
-    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_746, 1);
-    stream->write((uint64_t*)&cgen_var_746, 1 * 8);
+    uint64_t cgen_var_754;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_754, 1);
+    stream->write((uint64_t*)&cgen_var_754, 1 * 8);
+    uint64_t cgen_var_755;
+    stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_755, 1);
+    stream->write((uint64_t*)&cgen_var_755, 1 * 8);
+    uint64_t cgen_var_756;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_756, 1);
+    stream->write((uint64_t*)&cgen_var_756, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_747 = (uint64_t)(uintptr_t)local_pData;
-    stream->putBe64(cgen_var_747);
+    uint64_t cgen_var_757 = (uint64_t)(uintptr_t)local_pData;
+    stream->putBe64(cgen_var_757);
     if (local_pData)
     {
         stream->write((void*)local_pData, sizeof(uint8_t));
@@ -10625,9 +10754,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_748;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_748, 1);
-        countingStream->write((uint64_t*)&cgen_var_748, 1 * 8);
+        uint64_t cgen_var_758;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_758, 1);
+        countingStream->write((uint64_t*)&cgen_var_758, 1 * 8);
         marshal_VkPhysicalDeviceExternalBufferInfo(countingStream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
         marshal_VkExternalBufferProperties(countingStream, (VkExternalBufferProperties*)(pExternalBufferProperties));
     }
@@ -10636,9 +10765,9 @@
     uint32_t opcode_vkGetPhysicalDeviceExternalBufferProperties = OP_vkGetPhysicalDeviceExternalBufferProperties;
     stream->write(&opcode_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
-    uint64_t cgen_var_749;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_749, 1);
-    stream->write((uint64_t*)&cgen_var_749, 1 * 8);
+    uint64_t cgen_var_759;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_759, 1);
+    stream->write((uint64_t*)&cgen_var_759, 1 * 8);
     marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
     marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
     unmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
@@ -10675,9 +10804,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_750;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_750, 1);
-        countingStream->write((uint64_t*)&cgen_var_750, 1 * 8);
+        uint64_t cgen_var_760;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_760, 1);
+        countingStream->write((uint64_t*)&cgen_var_760, 1 * 8);
         marshal_VkPhysicalDeviceExternalFenceInfo(countingStream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
         marshal_VkExternalFenceProperties(countingStream, (VkExternalFenceProperties*)(pExternalFenceProperties));
     }
@@ -10686,9 +10815,9 @@
     uint32_t opcode_vkGetPhysicalDeviceExternalFenceProperties = OP_vkGetPhysicalDeviceExternalFenceProperties;
     stream->write(&opcode_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
-    uint64_t cgen_var_751;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_751, 1);
-    stream->write((uint64_t*)&cgen_var_751, 1 * 8);
+    uint64_t cgen_var_761;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_761, 1);
+    stream->write((uint64_t*)&cgen_var_761, 1 * 8);
     marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
     marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
     unmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
@@ -10725,9 +10854,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_752;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_752, 1);
-        countingStream->write((uint64_t*)&cgen_var_752, 1 * 8);
+        uint64_t cgen_var_762;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_762, 1);
+        countingStream->write((uint64_t*)&cgen_var_762, 1 * 8);
         marshal_VkPhysicalDeviceExternalSemaphoreInfo(countingStream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
         marshal_VkExternalSemaphoreProperties(countingStream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
     }
@@ -10736,9 +10865,9 @@
     uint32_t opcode_vkGetPhysicalDeviceExternalSemaphoreProperties = OP_vkGetPhysicalDeviceExternalSemaphoreProperties;
     stream->write(&opcode_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
-    uint64_t cgen_var_753;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_753, 1);
-    stream->write((uint64_t*)&cgen_var_753, 1 * 8);
+    uint64_t cgen_var_763;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_763, 1);
+    stream->write((uint64_t*)&cgen_var_763, 1 * 8);
     marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
     marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
     unmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
@@ -10775,9 +10904,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_754;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_754, 1);
-        countingStream->write((uint64_t*)&cgen_var_754, 1 * 8);
+        uint64_t cgen_var_764;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_764, 1);
+        countingStream->write((uint64_t*)&cgen_var_764, 1 * 8);
         marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
         marshal_VkDescriptorSetLayoutSupport(countingStream, (VkDescriptorSetLayoutSupport*)(pSupport));
     }
@@ -10786,9 +10915,9 @@
     uint32_t opcode_vkGetDescriptorSetLayoutSupport = OP_vkGetDescriptorSetLayoutSupport;
     stream->write(&opcode_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
-    uint64_t cgen_var_755;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_755, 1);
-    stream->write((uint64_t*)&cgen_var_755, 1 * 8);
+    uint64_t cgen_var_765;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_765, 1);
+    stream->write((uint64_t*)&cgen_var_765, 1 * 8);
     marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
     marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
     unmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
@@ -10830,15 +10959,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_756;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_756, 1);
-        countingStream->write((uint64_t*)&cgen_var_756, 1 * 8);
-        uint64_t cgen_var_757;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_757, 1);
-        countingStream->write((uint64_t*)&cgen_var_757, 1 * 8);
+        uint64_t cgen_var_766;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_766, 1);
+        countingStream->write((uint64_t*)&cgen_var_766, 1 * 8);
+        uint64_t cgen_var_767;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_767, 1);
+        countingStream->write((uint64_t*)&cgen_var_767, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_758 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_758);
+        uint64_t cgen_var_768 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_768);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -10849,15 +10978,15 @@
     uint32_t opcode_vkDestroySurfaceKHR = OP_vkDestroySurfaceKHR;
     stream->write(&opcode_vkDestroySurfaceKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroySurfaceKHR, sizeof(uint32_t));
-    uint64_t cgen_var_759;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_759, 1);
-    stream->write((uint64_t*)&cgen_var_759, 1 * 8);
-    uint64_t cgen_var_760;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_760, 1);
-    stream->write((uint64_t*)&cgen_var_760, 1 * 8);
+    uint64_t cgen_var_769;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_769, 1);
+    stream->write((uint64_t*)&cgen_var_769, 1 * 8);
+    uint64_t cgen_var_770;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_770, 1);
+    stream->write((uint64_t*)&cgen_var_770, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_761 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_761);
+    uint64_t cgen_var_771 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_771);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -10886,13 +11015,13 @@
     local_surface = surface;
     countingStream->rewind();
     {
-        uint64_t cgen_var_762;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_762, 1);
-        countingStream->write((uint64_t*)&cgen_var_762, 1 * 8);
+        uint64_t cgen_var_772;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_772, 1);
+        countingStream->write((uint64_t*)&cgen_var_772, 1 * 8);
         countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
-        uint64_t cgen_var_763;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_763, 1);
-        countingStream->write((uint64_t*)&cgen_var_763, 1 * 8);
+        uint64_t cgen_var_773;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_773, 1);
+        countingStream->write((uint64_t*)&cgen_var_773, 1 * 8);
         countingStream->write((VkBool32*)pSupported, sizeof(VkBool32));
     }
     uint32_t packetSize_vkGetPhysicalDeviceSurfaceSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -10900,13 +11029,13 @@
     uint32_t opcode_vkGetPhysicalDeviceSurfaceSupportKHR = OP_vkGetPhysicalDeviceSurfaceSupportKHR;
     stream->write(&opcode_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t));
-    uint64_t cgen_var_764;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_764, 1);
-    stream->write((uint64_t*)&cgen_var_764, 1 * 8);
+    uint64_t cgen_var_774;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_774, 1);
+    stream->write((uint64_t*)&cgen_var_774, 1 * 8);
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
-    uint64_t cgen_var_765;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_765, 1);
-    stream->write((uint64_t*)&cgen_var_765, 1 * 8);
+    uint64_t cgen_var_775;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_775, 1);
+    stream->write((uint64_t*)&cgen_var_775, 1 * 8);
     stream->write((VkBool32*)pSupported, sizeof(VkBool32));
     stream->read((VkBool32*)pSupported, sizeof(VkBool32));
     VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
@@ -10935,12 +11064,12 @@
     local_surface = surface;
     countingStream->rewind();
     {
-        uint64_t cgen_var_766;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_766, 1);
-        countingStream->write((uint64_t*)&cgen_var_766, 1 * 8);
-        uint64_t cgen_var_767;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_767, 1);
-        countingStream->write((uint64_t*)&cgen_var_767, 1 * 8);
+        uint64_t cgen_var_776;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_776, 1);
+        countingStream->write((uint64_t*)&cgen_var_776, 1 * 8);
+        uint64_t cgen_var_777;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_777, 1);
+        countingStream->write((uint64_t*)&cgen_var_777, 1 * 8);
         marshal_VkSurfaceCapabilitiesKHR(countingStream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
     }
     uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -10948,12 +11077,12 @@
     uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
     stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_768;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_768, 1);
-    stream->write((uint64_t*)&cgen_var_768, 1 * 8);
-    uint64_t cgen_var_769;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_769, 1);
-    stream->write((uint64_t*)&cgen_var_769, 1 * 8);
+    uint64_t cgen_var_778;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_778, 1);
+    stream->write((uint64_t*)&cgen_var_778, 1 * 8);
+    uint64_t cgen_var_779;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_779, 1);
+    stream->write((uint64_t*)&cgen_var_779, 1 * 8);
     marshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
     unmarshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
     if (pSurfaceCapabilities)
@@ -10987,22 +11116,22 @@
     local_surface = surface;
     countingStream->rewind();
     {
-        uint64_t cgen_var_770;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_770, 1);
-        countingStream->write((uint64_t*)&cgen_var_770, 1 * 8);
-        uint64_t cgen_var_771;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_771, 1);
-        countingStream->write((uint64_t*)&cgen_var_771, 1 * 8);
+        uint64_t cgen_var_780;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_780, 1);
+        countingStream->write((uint64_t*)&cgen_var_780, 1 * 8);
+        uint64_t cgen_var_781;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_781, 1);
+        countingStream->write((uint64_t*)&cgen_var_781, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_772 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
-        countingStream->putBe64(cgen_var_772);
+        uint64_t cgen_var_782 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+        countingStream->putBe64(cgen_var_782);
         if (pSurfaceFormatCount)
         {
             countingStream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_773 = (uint64_t)(uintptr_t)pSurfaceFormats;
-        countingStream->putBe64(cgen_var_773);
+        uint64_t cgen_var_783 = (uint64_t)(uintptr_t)pSurfaceFormats;
+        countingStream->putBe64(cgen_var_783);
         if (pSurfaceFormats)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
@@ -11016,22 +11145,22 @@
     uint32_t opcode_vkGetPhysicalDeviceSurfaceFormatsKHR = OP_vkGetPhysicalDeviceSurfaceFormatsKHR;
     stream->write(&opcode_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t));
-    uint64_t cgen_var_774;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_774, 1);
-    stream->write((uint64_t*)&cgen_var_774, 1 * 8);
-    uint64_t cgen_var_775;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_775, 1);
-    stream->write((uint64_t*)&cgen_var_775, 1 * 8);
+    uint64_t cgen_var_784;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_784, 1);
+    stream->write((uint64_t*)&cgen_var_784, 1 * 8);
+    uint64_t cgen_var_785;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_785, 1);
+    stream->write((uint64_t*)&cgen_var_785, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_776 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
-    stream->putBe64(cgen_var_776);
+    uint64_t cgen_var_786 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+    stream->putBe64(cgen_var_786);
     if (pSurfaceFormatCount)
     {
         stream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_777 = (uint64_t)(uintptr_t)pSurfaceFormats;
-    stream->putBe64(cgen_var_777);
+    uint64_t cgen_var_787 = (uint64_t)(uintptr_t)pSurfaceFormats;
+    stream->putBe64(cgen_var_787);
     if (pSurfaceFormats)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
@@ -11098,22 +11227,22 @@
     local_surface = surface;
     countingStream->rewind();
     {
-        uint64_t cgen_var_780;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_780, 1);
-        countingStream->write((uint64_t*)&cgen_var_780, 1 * 8);
-        uint64_t cgen_var_781;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_781, 1);
-        countingStream->write((uint64_t*)&cgen_var_781, 1 * 8);
+        uint64_t cgen_var_790;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_790, 1);
+        countingStream->write((uint64_t*)&cgen_var_790, 1 * 8);
+        uint64_t cgen_var_791;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_791, 1);
+        countingStream->write((uint64_t*)&cgen_var_791, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_782 = (uint64_t)(uintptr_t)pPresentModeCount;
-        countingStream->putBe64(cgen_var_782);
+        uint64_t cgen_var_792 = (uint64_t)(uintptr_t)pPresentModeCount;
+        countingStream->putBe64(cgen_var_792);
         if (pPresentModeCount)
         {
             countingStream->write((uint32_t*)pPresentModeCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_783 = (uint64_t)(uintptr_t)pPresentModes;
-        countingStream->putBe64(cgen_var_783);
+        uint64_t cgen_var_793 = (uint64_t)(uintptr_t)pPresentModes;
+        countingStream->putBe64(cgen_var_793);
         if (pPresentModes)
         {
             countingStream->write((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
@@ -11124,22 +11253,22 @@
     uint32_t opcode_vkGetPhysicalDeviceSurfacePresentModesKHR = OP_vkGetPhysicalDeviceSurfacePresentModesKHR;
     stream->write(&opcode_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_784;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_784, 1);
-    stream->write((uint64_t*)&cgen_var_784, 1 * 8);
-    uint64_t cgen_var_785;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_785, 1);
-    stream->write((uint64_t*)&cgen_var_785, 1 * 8);
+    uint64_t cgen_var_794;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_794, 1);
+    stream->write((uint64_t*)&cgen_var_794, 1 * 8);
+    uint64_t cgen_var_795;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_795, 1);
+    stream->write((uint64_t*)&cgen_var_795, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_786 = (uint64_t)(uintptr_t)pPresentModeCount;
-    stream->putBe64(cgen_var_786);
+    uint64_t cgen_var_796 = (uint64_t)(uintptr_t)pPresentModeCount;
+    stream->putBe64(cgen_var_796);
     if (pPresentModeCount)
     {
         stream->write((uint32_t*)pPresentModeCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_787 = (uint64_t)(uintptr_t)pPresentModes;
-    stream->putBe64(cgen_var_787);
+    uint64_t cgen_var_797 = (uint64_t)(uintptr_t)pPresentModes;
+    stream->putBe64(cgen_var_797);
     if (pPresentModes)
     {
         stream->write((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
@@ -11216,46 +11345,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_790;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_790, 1);
-        countingStream->write((uint64_t*)&cgen_var_790, 1 * 8);
+        uint64_t cgen_var_800;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_800, 1);
+        countingStream->write((uint64_t*)&cgen_var_800, 1 * 8);
         marshal_VkSwapchainCreateInfoKHR(countingStream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_791 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_791);
+        uint64_t cgen_var_801 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_801);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_792;
-        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_792, 1);
-        countingStream->write((uint64_t*)&cgen_var_792, 8);
+        uint64_t cgen_var_802;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_802, 1);
+        countingStream->write((uint64_t*)&cgen_var_802, 8);
     }
     uint32_t packetSize_vkCreateSwapchainKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateSwapchainKHR = OP_vkCreateSwapchainKHR;
     stream->write(&opcode_vkCreateSwapchainKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateSwapchainKHR, sizeof(uint32_t));
-    uint64_t cgen_var_793;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_793, 1);
-    stream->write((uint64_t*)&cgen_var_793, 1 * 8);
+    uint64_t cgen_var_803;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_803, 1);
+    stream->write((uint64_t*)&cgen_var_803, 1 * 8);
     marshal_VkSwapchainCreateInfoKHR(stream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_794 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_794);
+    uint64_t cgen_var_804 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_804);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_795;
-    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_795, 1);
-    stream->write((uint64_t*)&cgen_var_795, 8);
+    uint64_t cgen_var_805;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_805, 1);
+    stream->write((uint64_t*)&cgen_var_805, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_796;
-    stream->read((uint64_t*)&cgen_var_796, 8);
-    stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_796, (VkSwapchainKHR*)pSwapchain, 1);
+    uint64_t cgen_var_806;
+    stream->read((uint64_t*)&cgen_var_806, 8);
+    stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_806, (VkSwapchainKHR*)pSwapchain, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSwapchainKHR_VkResult_return, sizeof(VkResult));
@@ -11295,15 +11424,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_797;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_797, 1);
-        countingStream->write((uint64_t*)&cgen_var_797, 1 * 8);
-        uint64_t cgen_var_798;
-        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_798, 1);
-        countingStream->write((uint64_t*)&cgen_var_798, 1 * 8);
+        uint64_t cgen_var_807;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_807, 1);
+        countingStream->write((uint64_t*)&cgen_var_807, 1 * 8);
+        uint64_t cgen_var_808;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_808, 1);
+        countingStream->write((uint64_t*)&cgen_var_808, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_799 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_799);
+        uint64_t cgen_var_809 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_809);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -11314,15 +11443,15 @@
     uint32_t opcode_vkDestroySwapchainKHR = OP_vkDestroySwapchainKHR;
     stream->write(&opcode_vkDestroySwapchainKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroySwapchainKHR, sizeof(uint32_t));
-    uint64_t cgen_var_800;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_800, 1);
-    stream->write((uint64_t*)&cgen_var_800, 1 * 8);
-    uint64_t cgen_var_801;
-    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_801, 1);
-    stream->write((uint64_t*)&cgen_var_801, 1 * 8);
+    uint64_t cgen_var_810;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_810, 1);
+    stream->write((uint64_t*)&cgen_var_810, 1 * 8);
+    uint64_t cgen_var_811;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_811, 1);
+    stream->write((uint64_t*)&cgen_var_811, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_802 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_802);
+    uint64_t cgen_var_812 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_812);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -11349,30 +11478,30 @@
     local_swapchain = swapchain;
     countingStream->rewind();
     {
-        uint64_t cgen_var_803;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_803, 1);
-        countingStream->write((uint64_t*)&cgen_var_803, 1 * 8);
-        uint64_t cgen_var_804;
-        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_804, 1);
-        countingStream->write((uint64_t*)&cgen_var_804, 1 * 8);
+        uint64_t cgen_var_813;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_813, 1);
+        countingStream->write((uint64_t*)&cgen_var_813, 1 * 8);
+        uint64_t cgen_var_814;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_814, 1);
+        countingStream->write((uint64_t*)&cgen_var_814, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_805 = (uint64_t)(uintptr_t)pSwapchainImageCount;
-        countingStream->putBe64(cgen_var_805);
+        uint64_t cgen_var_815 = (uint64_t)(uintptr_t)pSwapchainImageCount;
+        countingStream->putBe64(cgen_var_815);
         if (pSwapchainImageCount)
         {
             countingStream->write((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_806 = (uint64_t)(uintptr_t)pSwapchainImages;
-        countingStream->putBe64(cgen_var_806);
+        uint64_t cgen_var_816 = (uint64_t)(uintptr_t)pSwapchainImages;
+        countingStream->putBe64(cgen_var_816);
         if (pSwapchainImages)
         {
             if ((*(pSwapchainImageCount)))
             {
-                uint64_t* cgen_var_807;
-                countingStream->alloc((void**)&cgen_var_807, (*(pSwapchainImageCount)) * 8);
-                countingStream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_807, (*(pSwapchainImageCount)));
-                countingStream->write((uint64_t*)cgen_var_807, (*(pSwapchainImageCount)) * 8);
+                uint64_t* cgen_var_817;
+                countingStream->alloc((void**)&cgen_var_817, (*(pSwapchainImageCount)) * 8);
+                countingStream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_817, (*(pSwapchainImageCount)));
+                countingStream->write((uint64_t*)cgen_var_817, (*(pSwapchainImageCount)) * 8);
             }
         }
     }
@@ -11381,31 +11510,31 @@
     uint32_t opcode_vkGetSwapchainImagesKHR = OP_vkGetSwapchainImagesKHR;
     stream->write(&opcode_vkGetSwapchainImagesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetSwapchainImagesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_808;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_808, 1);
-    stream->write((uint64_t*)&cgen_var_808, 1 * 8);
-    uint64_t cgen_var_809;
-    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_809, 1);
-    stream->write((uint64_t*)&cgen_var_809, 1 * 8);
+    uint64_t cgen_var_818;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_818, 1);
+    stream->write((uint64_t*)&cgen_var_818, 1 * 8);
+    uint64_t cgen_var_819;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_819, 1);
+    stream->write((uint64_t*)&cgen_var_819, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_810 = (uint64_t)(uintptr_t)pSwapchainImageCount;
-    stream->putBe64(cgen_var_810);
+    uint64_t cgen_var_820 = (uint64_t)(uintptr_t)pSwapchainImageCount;
+    stream->putBe64(cgen_var_820);
     if (pSwapchainImageCount)
     {
         stream->write((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
     // WARNING PTR CHECK
-    uint64_t cgen_var_811 = (uint64_t)(uintptr_t)pSwapchainImages;
-    stream->putBe64(cgen_var_811);
+    uint64_t cgen_var_821 = (uint64_t)(uintptr_t)pSwapchainImages;
+    stream->putBe64(cgen_var_821);
     if (pSwapchainImages)
     {
         if ((*(pSwapchainImageCount)))
         {
-            uint64_t* cgen_var_812;
-            stream->alloc((void**)&cgen_var_812, (*(pSwapchainImageCount)) * 8);
-            stream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_812, (*(pSwapchainImageCount)));
-            stream->write((uint64_t*)cgen_var_812, (*(pSwapchainImageCount)) * 8);
+            uint64_t* cgen_var_822;
+            stream->alloc((void**)&cgen_var_822, (*(pSwapchainImageCount)) * 8);
+            stream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_822, (*(pSwapchainImageCount)));
+            stream->write((uint64_t*)cgen_var_822, (*(pSwapchainImageCount)) * 8);
         }
     }
     stream->setHandleMapping(resources->unwrapMapping());
@@ -11431,10 +11560,10 @@
         }
         if ((*(pSwapchainImageCount)))
         {
-            uint64_t* cgen_var_815;
-            stream->alloc((void**)&cgen_var_815, (*(pSwapchainImageCount)) * 8);
-            stream->read((uint64_t*)cgen_var_815, (*(pSwapchainImageCount)) * 8);
-            stream->handleMapping()->mapHandles_u64_VkImage(cgen_var_815, (VkImage*)pSwapchainImages, (*(pSwapchainImageCount)));
+            uint64_t* cgen_var_825;
+            stream->alloc((void**)&cgen_var_825, (*(pSwapchainImageCount)) * 8);
+            stream->read((uint64_t*)cgen_var_825, (*(pSwapchainImageCount)) * 8);
+            stream->handleMapping()->mapHandles_u64_VkImage(cgen_var_825, (VkImage*)pSwapchainImages, (*(pSwapchainImageCount)));
         }
     }
     VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
@@ -11472,19 +11601,19 @@
     local_fence = fence;
     countingStream->rewind();
     {
-        uint64_t cgen_var_816;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_816, 1);
-        countingStream->write((uint64_t*)&cgen_var_816, 1 * 8);
-        uint64_t cgen_var_817;
-        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_817, 1);
-        countingStream->write((uint64_t*)&cgen_var_817, 1 * 8);
+        uint64_t cgen_var_826;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_826, 1);
+        countingStream->write((uint64_t*)&cgen_var_826, 1 * 8);
+        uint64_t cgen_var_827;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_827, 1);
+        countingStream->write((uint64_t*)&cgen_var_827, 1 * 8);
         countingStream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
-        uint64_t cgen_var_818;
-        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_818, 1);
-        countingStream->write((uint64_t*)&cgen_var_818, 1 * 8);
-        uint64_t cgen_var_819;
-        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_819, 1);
-        countingStream->write((uint64_t*)&cgen_var_819, 1 * 8);
+        uint64_t cgen_var_828;
+        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_828, 1);
+        countingStream->write((uint64_t*)&cgen_var_828, 1 * 8);
+        uint64_t cgen_var_829;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_829, 1);
+        countingStream->write((uint64_t*)&cgen_var_829, 1 * 8);
         countingStream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
     }
     uint32_t packetSize_vkAcquireNextImageKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -11492,19 +11621,19 @@
     uint32_t opcode_vkAcquireNextImageKHR = OP_vkAcquireNextImageKHR;
     stream->write(&opcode_vkAcquireNextImageKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkAcquireNextImageKHR, sizeof(uint32_t));
-    uint64_t cgen_var_820;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_820, 1);
-    stream->write((uint64_t*)&cgen_var_820, 1 * 8);
-    uint64_t cgen_var_821;
-    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_821, 1);
-    stream->write((uint64_t*)&cgen_var_821, 1 * 8);
+    uint64_t cgen_var_830;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_830, 1);
+    stream->write((uint64_t*)&cgen_var_830, 1 * 8);
+    uint64_t cgen_var_831;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_831, 1);
+    stream->write((uint64_t*)&cgen_var_831, 1 * 8);
     stream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
-    uint64_t cgen_var_822;
-    stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_822, 1);
-    stream->write((uint64_t*)&cgen_var_822, 1 * 8);
-    uint64_t cgen_var_823;
-    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_823, 1);
-    stream->write((uint64_t*)&cgen_var_823, 1 * 8);
+    uint64_t cgen_var_832;
+    stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_832, 1);
+    stream->write((uint64_t*)&cgen_var_832, 1 * 8);
+    uint64_t cgen_var_833;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_833, 1);
+    stream->write((uint64_t*)&cgen_var_833, 1 * 8);
     stream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
     stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
     VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
@@ -11541,9 +11670,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_824;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_824, 1);
-        countingStream->write((uint64_t*)&cgen_var_824, 1 * 8);
+        uint64_t cgen_var_834;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_834, 1);
+        countingStream->write((uint64_t*)&cgen_var_834, 1 * 8);
         marshal_VkPresentInfoKHR(countingStream, (VkPresentInfoKHR*)(local_pPresentInfo));
     }
     uint32_t packetSize_vkQueuePresentKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -11551,9 +11680,9 @@
     uint32_t opcode_vkQueuePresentKHR = OP_vkQueuePresentKHR;
     stream->write(&opcode_vkQueuePresentKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkQueuePresentKHR, sizeof(uint32_t));
-    uint64_t cgen_var_825;
-    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_825, 1);
-    stream->write((uint64_t*)&cgen_var_825, 1 * 8);
+    uint64_t cgen_var_835;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_835, 1);
+    stream->write((uint64_t*)&cgen_var_835, 1 * 8);
     marshal_VkPresentInfoKHR(stream, (VkPresentInfoKHR*)(local_pPresentInfo));
     VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
     stream->read(&vkQueuePresentKHR_VkResult_return, sizeof(VkResult));
@@ -11578,9 +11707,9 @@
     local_device = device;
     countingStream->rewind();
     {
-        uint64_t cgen_var_826;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_826, 1);
-        countingStream->write((uint64_t*)&cgen_var_826, 1 * 8);
+        uint64_t cgen_var_836;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_836, 1);
+        countingStream->write((uint64_t*)&cgen_var_836, 1 * 8);
         marshal_VkDeviceGroupPresentCapabilitiesKHR(countingStream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
     }
     uint32_t packetSize_vkGetDeviceGroupPresentCapabilitiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -11588,9 +11717,9 @@
     uint32_t opcode_vkGetDeviceGroupPresentCapabilitiesKHR = OP_vkGetDeviceGroupPresentCapabilitiesKHR;
     stream->write(&opcode_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_827;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_827, 1);
-    stream->write((uint64_t*)&cgen_var_827, 1 * 8);
+    uint64_t cgen_var_837;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_837, 1);
+    stream->write((uint64_t*)&cgen_var_837, 1 * 8);
     marshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
     unmarshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
     if (pDeviceGroupPresentCapabilities)
@@ -11623,15 +11752,15 @@
     local_surface = surface;
     countingStream->rewind();
     {
-        uint64_t cgen_var_828;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_828, 1);
-        countingStream->write((uint64_t*)&cgen_var_828, 1 * 8);
-        uint64_t cgen_var_829;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_829, 1);
-        countingStream->write((uint64_t*)&cgen_var_829, 1 * 8);
+        uint64_t cgen_var_838;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_838, 1);
+        countingStream->write((uint64_t*)&cgen_var_838, 1 * 8);
+        uint64_t cgen_var_839;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_839, 1);
+        countingStream->write((uint64_t*)&cgen_var_839, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_830 = (uint64_t)(uintptr_t)pModes;
-        countingStream->putBe64(cgen_var_830);
+        uint64_t cgen_var_840 = (uint64_t)(uintptr_t)pModes;
+        countingStream->putBe64(cgen_var_840);
         if (pModes)
         {
             countingStream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
@@ -11642,15 +11771,15 @@
     uint32_t opcode_vkGetDeviceGroupSurfacePresentModesKHR = OP_vkGetDeviceGroupSurfacePresentModesKHR;
     stream->write(&opcode_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_831;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_831, 1);
-    stream->write((uint64_t*)&cgen_var_831, 1 * 8);
-    uint64_t cgen_var_832;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_832, 1);
-    stream->write((uint64_t*)&cgen_var_832, 1 * 8);
+    uint64_t cgen_var_841;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_841, 1);
+    stream->write((uint64_t*)&cgen_var_841, 1 * 8);
+    uint64_t cgen_var_842;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_842, 1);
+    stream->write((uint64_t*)&cgen_var_842, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_833 = (uint64_t)(uintptr_t)pModes;
-    stream->putBe64(cgen_var_833);
+    uint64_t cgen_var_843 = (uint64_t)(uintptr_t)pModes;
+    stream->putBe64(cgen_var_843);
     if (pModes)
     {
         stream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
@@ -11693,22 +11822,22 @@
     local_surface = surface;
     countingStream->rewind();
     {
-        uint64_t cgen_var_835;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_835, 1);
-        countingStream->write((uint64_t*)&cgen_var_835, 1 * 8);
-        uint64_t cgen_var_836;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_836, 1);
-        countingStream->write((uint64_t*)&cgen_var_836, 1 * 8);
+        uint64_t cgen_var_845;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_845, 1);
+        countingStream->write((uint64_t*)&cgen_var_845, 1 * 8);
+        uint64_t cgen_var_846;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_846, 1);
+        countingStream->write((uint64_t*)&cgen_var_846, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_837 = (uint64_t)(uintptr_t)pRectCount;
-        countingStream->putBe64(cgen_var_837);
+        uint64_t cgen_var_847 = (uint64_t)(uintptr_t)pRectCount;
+        countingStream->putBe64(cgen_var_847);
         if (pRectCount)
         {
             countingStream->write((uint32_t*)pRectCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_838 = (uint64_t)(uintptr_t)pRects;
-        countingStream->putBe64(cgen_var_838);
+        uint64_t cgen_var_848 = (uint64_t)(uintptr_t)pRects;
+        countingStream->putBe64(cgen_var_848);
         if (pRects)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
@@ -11722,22 +11851,22 @@
     uint32_t opcode_vkGetPhysicalDevicePresentRectanglesKHR = OP_vkGetPhysicalDevicePresentRectanglesKHR;
     stream->write(&opcode_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_839;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_839, 1);
-    stream->write((uint64_t*)&cgen_var_839, 1 * 8);
-    uint64_t cgen_var_840;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_840, 1);
-    stream->write((uint64_t*)&cgen_var_840, 1 * 8);
+    uint64_t cgen_var_849;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_849, 1);
+    stream->write((uint64_t*)&cgen_var_849, 1 * 8);
+    uint64_t cgen_var_850;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_850, 1);
+    stream->write((uint64_t*)&cgen_var_850, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_841 = (uint64_t)(uintptr_t)pRectCount;
-    stream->putBe64(cgen_var_841);
+    uint64_t cgen_var_851 = (uint64_t)(uintptr_t)pRectCount;
+    stream->putBe64(cgen_var_851);
     if (pRectCount)
     {
         stream->write((uint32_t*)pRectCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_842 = (uint64_t)(uintptr_t)pRects;
-    stream->putBe64(cgen_var_842);
+    uint64_t cgen_var_852 = (uint64_t)(uintptr_t)pRects;
+    stream->putBe64(cgen_var_852);
     if (pRects)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
@@ -11812,9 +11941,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_845;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_845, 1);
-        countingStream->write((uint64_t*)&cgen_var_845, 1 * 8);
+        uint64_t cgen_var_855;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_855, 1);
+        countingStream->write((uint64_t*)&cgen_var_855, 1 * 8);
         marshal_VkAcquireNextImageInfoKHR(countingStream, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
         countingStream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
     }
@@ -11823,9 +11952,9 @@
     uint32_t opcode_vkAcquireNextImage2KHR = OP_vkAcquireNextImage2KHR;
     stream->write(&opcode_vkAcquireNextImage2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkAcquireNextImage2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_846;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_846, 1);
-    stream->write((uint64_t*)&cgen_var_846, 1 * 8);
+    uint64_t cgen_var_856;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_856, 1);
+    stream->write((uint64_t*)&cgen_var_856, 1 * 8);
     marshal_VkAcquireNextImageInfoKHR(stream, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
     stream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
     stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
@@ -11855,19 +11984,19 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_847;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_847, 1);
-        countingStream->write((uint64_t*)&cgen_var_847, 1 * 8);
+        uint64_t cgen_var_857;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_857, 1);
+        countingStream->write((uint64_t*)&cgen_var_857, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_848 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_848);
+        uint64_t cgen_var_858 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_858);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_849 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_849);
+        uint64_t cgen_var_859 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_859);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -11881,19 +12010,19 @@
     uint32_t opcode_vkGetPhysicalDeviceDisplayPropertiesKHR = OP_vkGetPhysicalDeviceDisplayPropertiesKHR;
     stream->write(&opcode_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_850;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_850, 1);
-    stream->write((uint64_t*)&cgen_var_850, 1 * 8);
+    uint64_t cgen_var_860;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_860, 1);
+    stream->write((uint64_t*)&cgen_var_860, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_851 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_851);
+    uint64_t cgen_var_861 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_861);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_852 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_852);
+    uint64_t cgen_var_862 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_862);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -11957,19 +12086,19 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_855;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_855, 1);
-        countingStream->write((uint64_t*)&cgen_var_855, 1 * 8);
+        uint64_t cgen_var_865;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_865, 1);
+        countingStream->write((uint64_t*)&cgen_var_865, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_856 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_856);
+        uint64_t cgen_var_866 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_866);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_857 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_857);
+        uint64_t cgen_var_867 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_867);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -11983,19 +12112,19 @@
     uint32_t opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
     stream->write(&opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_858;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_858, 1);
-    stream->write((uint64_t*)&cgen_var_858, 1 * 8);
+    uint64_t cgen_var_868;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_868, 1);
+    stream->write((uint64_t*)&cgen_var_868, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_859 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_859);
+    uint64_t cgen_var_869 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_869);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_860 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_860);
+    uint64_t cgen_var_870 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_870);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -12062,28 +12191,28 @@
     local_planeIndex = planeIndex;
     countingStream->rewind();
     {
-        uint64_t cgen_var_863;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_863, 1);
-        countingStream->write((uint64_t*)&cgen_var_863, 1 * 8);
+        uint64_t cgen_var_873;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_873, 1);
+        countingStream->write((uint64_t*)&cgen_var_873, 1 * 8);
         countingStream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
         // WARNING PTR CHECK
-        uint64_t cgen_var_864 = (uint64_t)(uintptr_t)pDisplayCount;
-        countingStream->putBe64(cgen_var_864);
+        uint64_t cgen_var_874 = (uint64_t)(uintptr_t)pDisplayCount;
+        countingStream->putBe64(cgen_var_874);
         if (pDisplayCount)
         {
             countingStream->write((uint32_t*)pDisplayCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_865 = (uint64_t)(uintptr_t)pDisplays;
-        countingStream->putBe64(cgen_var_865);
+        uint64_t cgen_var_875 = (uint64_t)(uintptr_t)pDisplays;
+        countingStream->putBe64(cgen_var_875);
         if (pDisplays)
         {
             if ((*(pDisplayCount)))
             {
-                uint64_t* cgen_var_866;
-                countingStream->alloc((void**)&cgen_var_866, (*(pDisplayCount)) * 8);
-                countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_866, (*(pDisplayCount)));
-                countingStream->write((uint64_t*)cgen_var_866, (*(pDisplayCount)) * 8);
+                uint64_t* cgen_var_876;
+                countingStream->alloc((void**)&cgen_var_876, (*(pDisplayCount)) * 8);
+                countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_876, (*(pDisplayCount)));
+                countingStream->write((uint64_t*)cgen_var_876, (*(pDisplayCount)) * 8);
             }
         }
     }
@@ -12092,29 +12221,29 @@
     uint32_t opcode_vkGetDisplayPlaneSupportedDisplaysKHR = OP_vkGetDisplayPlaneSupportedDisplaysKHR;
     stream->write(&opcode_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t));
-    uint64_t cgen_var_867;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_867, 1);
-    stream->write((uint64_t*)&cgen_var_867, 1 * 8);
+    uint64_t cgen_var_877;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_877, 1);
+    stream->write((uint64_t*)&cgen_var_877, 1 * 8);
     stream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_868 = (uint64_t)(uintptr_t)pDisplayCount;
-    stream->putBe64(cgen_var_868);
+    uint64_t cgen_var_878 = (uint64_t)(uintptr_t)pDisplayCount;
+    stream->putBe64(cgen_var_878);
     if (pDisplayCount)
     {
         stream->write((uint32_t*)pDisplayCount, sizeof(uint32_t));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
     // WARNING PTR CHECK
-    uint64_t cgen_var_869 = (uint64_t)(uintptr_t)pDisplays;
-    stream->putBe64(cgen_var_869);
+    uint64_t cgen_var_879 = (uint64_t)(uintptr_t)pDisplays;
+    stream->putBe64(cgen_var_879);
     if (pDisplays)
     {
         if ((*(pDisplayCount)))
         {
-            uint64_t* cgen_var_870;
-            stream->alloc((void**)&cgen_var_870, (*(pDisplayCount)) * 8);
-            stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_870, (*(pDisplayCount)));
-            stream->write((uint64_t*)cgen_var_870, (*(pDisplayCount)) * 8);
+            uint64_t* cgen_var_880;
+            stream->alloc((void**)&cgen_var_880, (*(pDisplayCount)) * 8);
+            stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_880, (*(pDisplayCount)));
+            stream->write((uint64_t*)cgen_var_880, (*(pDisplayCount)) * 8);
         }
     }
     stream->setHandleMapping(resources->unwrapMapping());
@@ -12140,10 +12269,10 @@
         }
         if ((*(pDisplayCount)))
         {
-            uint64_t* cgen_var_873;
-            stream->alloc((void**)&cgen_var_873, (*(pDisplayCount)) * 8);
-            stream->read((uint64_t*)cgen_var_873, (*(pDisplayCount)) * 8);
-            stream->handleMapping()->mapHandles_u64_VkDisplayKHR(cgen_var_873, (VkDisplayKHR*)pDisplays, (*(pDisplayCount)));
+            uint64_t* cgen_var_883;
+            stream->alloc((void**)&cgen_var_883, (*(pDisplayCount)) * 8);
+            stream->read((uint64_t*)cgen_var_883, (*(pDisplayCount)) * 8);
+            stream->handleMapping()->mapHandles_u64_VkDisplayKHR(cgen_var_883, (VkDisplayKHR*)pDisplays, (*(pDisplayCount)));
         }
     }
     VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
@@ -12173,22 +12302,22 @@
     local_display = display;
     countingStream->rewind();
     {
-        uint64_t cgen_var_874;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_874, 1);
-        countingStream->write((uint64_t*)&cgen_var_874, 1 * 8);
-        uint64_t cgen_var_875;
-        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_875, 1);
-        countingStream->write((uint64_t*)&cgen_var_875, 1 * 8);
+        uint64_t cgen_var_884;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_884, 1);
+        countingStream->write((uint64_t*)&cgen_var_884, 1 * 8);
+        uint64_t cgen_var_885;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_885, 1);
+        countingStream->write((uint64_t*)&cgen_var_885, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_876 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_876);
+        uint64_t cgen_var_886 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_886);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_877 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_877);
+        uint64_t cgen_var_887 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_887);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -12202,22 +12331,22 @@
     uint32_t opcode_vkGetDisplayModePropertiesKHR = OP_vkGetDisplayModePropertiesKHR;
     stream->write(&opcode_vkGetDisplayModePropertiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDisplayModePropertiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_878;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_878, 1);
-    stream->write((uint64_t*)&cgen_var_878, 1 * 8);
-    uint64_t cgen_var_879;
-    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_879, 1);
-    stream->write((uint64_t*)&cgen_var_879, 1 * 8);
+    uint64_t cgen_var_888;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_888, 1);
+    stream->write((uint64_t*)&cgen_var_888, 1 * 8);
+    uint64_t cgen_var_889;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_889, 1);
+    stream->write((uint64_t*)&cgen_var_889, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_880 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_880);
+    uint64_t cgen_var_890 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_890);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_881 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_881);
+    uint64_t cgen_var_891 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_891);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -12308,52 +12437,52 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_884;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_884, 1);
-        countingStream->write((uint64_t*)&cgen_var_884, 1 * 8);
-        uint64_t cgen_var_885;
-        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_885, 1);
-        countingStream->write((uint64_t*)&cgen_var_885, 1 * 8);
+        uint64_t cgen_var_894;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_894, 1);
+        countingStream->write((uint64_t*)&cgen_var_894, 1 * 8);
+        uint64_t cgen_var_895;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_895, 1);
+        countingStream->write((uint64_t*)&cgen_var_895, 1 * 8);
         marshal_VkDisplayModeCreateInfoKHR(countingStream, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_886 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_886);
+        uint64_t cgen_var_896 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_896);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_887;
-        countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_887, 1);
-        countingStream->write((uint64_t*)&cgen_var_887, 8);
+        uint64_t cgen_var_897;
+        countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_897, 1);
+        countingStream->write((uint64_t*)&cgen_var_897, 8);
     }
     uint32_t packetSize_vkCreateDisplayModeKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateDisplayModeKHR = OP_vkCreateDisplayModeKHR;
     stream->write(&opcode_vkCreateDisplayModeKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateDisplayModeKHR, sizeof(uint32_t));
-    uint64_t cgen_var_888;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_888, 1);
-    stream->write((uint64_t*)&cgen_var_888, 1 * 8);
-    uint64_t cgen_var_889;
-    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_889, 1);
-    stream->write((uint64_t*)&cgen_var_889, 1 * 8);
+    uint64_t cgen_var_898;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_898, 1);
+    stream->write((uint64_t*)&cgen_var_898, 1 * 8);
+    uint64_t cgen_var_899;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_899, 1);
+    stream->write((uint64_t*)&cgen_var_899, 1 * 8);
     marshal_VkDisplayModeCreateInfoKHR(stream, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_890 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_890);
+    uint64_t cgen_var_900 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_900);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_891;
-    stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_891, 1);
-    stream->write((uint64_t*)&cgen_var_891, 8);
+    uint64_t cgen_var_901;
+    stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_901, 1);
+    stream->write((uint64_t*)&cgen_var_901, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_892;
-    stream->read((uint64_t*)&cgen_var_892, 8);
-    stream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_892, (VkDisplayModeKHR*)pMode, 1);
+    uint64_t cgen_var_902;
+    stream->read((uint64_t*)&cgen_var_902, 8);
+    stream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_902, (VkDisplayModeKHR*)pMode, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDisplayModeKHR_VkResult_return, sizeof(VkResult));
@@ -12384,12 +12513,12 @@
     local_planeIndex = planeIndex;
     countingStream->rewind();
     {
-        uint64_t cgen_var_893;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_893, 1);
-        countingStream->write((uint64_t*)&cgen_var_893, 1 * 8);
-        uint64_t cgen_var_894;
-        countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_894, 1);
-        countingStream->write((uint64_t*)&cgen_var_894, 1 * 8);
+        uint64_t cgen_var_903;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_903, 1);
+        countingStream->write((uint64_t*)&cgen_var_903, 1 * 8);
+        uint64_t cgen_var_904;
+        countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_904, 1);
+        countingStream->write((uint64_t*)&cgen_var_904, 1 * 8);
         countingStream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
         marshal_VkDisplayPlaneCapabilitiesKHR(countingStream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
     }
@@ -12398,12 +12527,12 @@
     uint32_t opcode_vkGetDisplayPlaneCapabilitiesKHR = OP_vkGetDisplayPlaneCapabilitiesKHR;
     stream->write(&opcode_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_895;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_895, 1);
-    stream->write((uint64_t*)&cgen_var_895, 1 * 8);
-    uint64_t cgen_var_896;
-    stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_896, 1);
-    stream->write((uint64_t*)&cgen_var_896, 1 * 8);
+    uint64_t cgen_var_905;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_905, 1);
+    stream->write((uint64_t*)&cgen_var_905, 1 * 8);
+    uint64_t cgen_var_906;
+    stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_906, 1);
+    stream->write((uint64_t*)&cgen_var_906, 1 * 8);
     stream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
     marshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
     unmarshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
@@ -12459,45 +12588,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_897;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_897, 1);
-        countingStream->write((uint64_t*)&cgen_var_897, 1 * 8);
+        uint64_t cgen_var_907;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_907, 1);
+        countingStream->write((uint64_t*)&cgen_var_907, 1 * 8);
         marshal_VkDisplaySurfaceCreateInfoKHR(countingStream, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_898 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_898);
+        uint64_t cgen_var_908 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_908);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_899;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_899, 1);
-        countingStream->write((uint64_t*)&cgen_var_899, 8);
+        uint64_t cgen_var_909;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_909, 1);
+        countingStream->write((uint64_t*)&cgen_var_909, 8);
     }
     uint32_t packetSize_vkCreateDisplayPlaneSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateDisplayPlaneSurfaceKHR = OP_vkCreateDisplayPlaneSurfaceKHR;
     stream->write(&opcode_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t));
-    uint64_t cgen_var_900;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_900, 1);
-    stream->write((uint64_t*)&cgen_var_900, 1 * 8);
+    uint64_t cgen_var_910;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_910, 1);
+    stream->write((uint64_t*)&cgen_var_910, 1 * 8);
     marshal_VkDisplaySurfaceCreateInfoKHR(stream, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_901 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_901);
+    uint64_t cgen_var_911 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_911);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_902;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_902, 1);
-    stream->write((uint64_t*)&cgen_var_902, 8);
+    uint64_t cgen_var_912;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_912, 1);
+    stream->write((uint64_t*)&cgen_var_912, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_903;
-    stream->read((uint64_t*)&cgen_var_903, 8);
-    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_903, (VkSurfaceKHR*)pSurface, 1);
+    uint64_t cgen_var_913;
+    stream->read((uint64_t*)&cgen_var_913, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_913, (VkSurfaceKHR*)pSurface, 1);
     VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDisplayPlaneSurfaceKHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -12557,27 +12686,27 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_904;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_904, 1);
-        countingStream->write((uint64_t*)&cgen_var_904, 1 * 8);
+        uint64_t cgen_var_914;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_914, 1);
+        countingStream->write((uint64_t*)&cgen_var_914, 1 * 8);
         countingStream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
         {
             marshal_VkSwapchainCreateInfoKHR(countingStream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_905 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_905);
+        uint64_t cgen_var_915 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_915);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
         if (((swapchainCount)))
         {
-            uint64_t* cgen_var_906;
-            countingStream->alloc((void**)&cgen_var_906, ((swapchainCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_906, ((swapchainCount)));
-            countingStream->write((uint64_t*)cgen_var_906, ((swapchainCount)) * 8);
+            uint64_t* cgen_var_916;
+            countingStream->alloc((void**)&cgen_var_916, ((swapchainCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_916, ((swapchainCount)));
+            countingStream->write((uint64_t*)cgen_var_916, ((swapchainCount)) * 8);
         }
     }
     uint32_t packetSize_vkCreateSharedSwapchainsKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -12585,17 +12714,17 @@
     uint32_t opcode_vkCreateSharedSwapchainsKHR = OP_vkCreateSharedSwapchainsKHR;
     stream->write(&opcode_vkCreateSharedSwapchainsKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateSharedSwapchainsKHR, sizeof(uint32_t));
-    uint64_t cgen_var_907;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_907, 1);
-    stream->write((uint64_t*)&cgen_var_907, 1 * 8);
+    uint64_t cgen_var_917;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_917, 1);
+    stream->write((uint64_t*)&cgen_var_917, 1 * 8);
     stream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
     {
         marshal_VkSwapchainCreateInfoKHR(stream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_908 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_908);
+    uint64_t cgen_var_918 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_918);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -12603,18 +12732,18 @@
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
     if (((swapchainCount)))
     {
-        uint64_t* cgen_var_909;
-        stream->alloc((void**)&cgen_var_909, ((swapchainCount)) * 8);
-        stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_909, ((swapchainCount)));
-        stream->write((uint64_t*)cgen_var_909, ((swapchainCount)) * 8);
+        uint64_t* cgen_var_919;
+        stream->alloc((void**)&cgen_var_919, ((swapchainCount)) * 8);
+        stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_919, ((swapchainCount)));
+        stream->write((uint64_t*)cgen_var_919, ((swapchainCount)) * 8);
     }
     stream->setHandleMapping(resources->unwrapMapping());
     if (((swapchainCount)))
     {
-        uint64_t* cgen_var_910;
-        stream->alloc((void**)&cgen_var_910, ((swapchainCount)) * 8);
-        stream->read((uint64_t*)cgen_var_910, ((swapchainCount)) * 8);
-        stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_910, (VkSwapchainKHR*)pSwapchains, ((swapchainCount)));
+        uint64_t* cgen_var_920;
+        stream->alloc((void**)&cgen_var_920, ((swapchainCount)) * 8);
+        stream->read((uint64_t*)cgen_var_920, ((swapchainCount)) * 8);
+        stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_920, (VkSwapchainKHR*)pSwapchains, ((swapchainCount)));
     }
     VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSharedSwapchainsKHR_VkResult_return, sizeof(VkResult));
@@ -12666,45 +12795,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_911;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_911, 1);
-        countingStream->write((uint64_t*)&cgen_var_911, 1 * 8);
+        uint64_t cgen_var_921;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_921, 1);
+        countingStream->write((uint64_t*)&cgen_var_921, 1 * 8);
         marshal_VkXlibSurfaceCreateInfoKHR(countingStream, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_912 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_912);
+        uint64_t cgen_var_922 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_922);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_913;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_913, 1);
-        countingStream->write((uint64_t*)&cgen_var_913, 8);
+        uint64_t cgen_var_923;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_923, 1);
+        countingStream->write((uint64_t*)&cgen_var_923, 8);
     }
     uint32_t packetSize_vkCreateXlibSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateXlibSurfaceKHR = OP_vkCreateXlibSurfaceKHR;
     stream->write(&opcode_vkCreateXlibSurfaceKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateXlibSurfaceKHR, sizeof(uint32_t));
-    uint64_t cgen_var_914;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_914, 1);
-    stream->write((uint64_t*)&cgen_var_914, 1 * 8);
+    uint64_t cgen_var_924;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_924, 1);
+    stream->write((uint64_t*)&cgen_var_924, 1 * 8);
     marshal_VkXlibSurfaceCreateInfoKHR(stream, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_915 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_915);
+    uint64_t cgen_var_925 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_925);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_916;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_916, 1);
-    stream->write((uint64_t*)&cgen_var_916, 8);
+    uint64_t cgen_var_926;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_926, 1);
+    stream->write((uint64_t*)&cgen_var_926, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_917;
-    stream->read((uint64_t*)&cgen_var_917, 8);
-    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_917, (VkSurfaceKHR*)pSurface, 1);
+    uint64_t cgen_var_927;
+    stream->read((uint64_t*)&cgen_var_927, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_927, (VkSurfaceKHR*)pSurface, 1);
     VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateXlibSurfaceKHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -12734,9 +12863,9 @@
     local_visualID = visualID;
     countingStream->rewind();
     {
-        uint64_t cgen_var_918;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_918, 1);
-        countingStream->write((uint64_t*)&cgen_var_918, 1 * 8);
+        uint64_t cgen_var_928;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_928, 1);
+        countingStream->write((uint64_t*)&cgen_var_928, 1 * 8);
         countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
         countingStream->write((Display*)dpy, sizeof(Display));
         countingStream->write((VisualID*)&local_visualID, sizeof(VisualID));
@@ -12746,9 +12875,9 @@
     uint32_t opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR = OP_vkGetPhysicalDeviceXlibPresentationSupportKHR;
     stream->write(&opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t));
-    uint64_t cgen_var_919;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_919, 1);
-    stream->write((uint64_t*)&cgen_var_919, 1 * 8);
+    uint64_t cgen_var_929;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_929, 1);
+    stream->write((uint64_t*)&cgen_var_929, 1 * 8);
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     stream->write((Display*)dpy, sizeof(Display));
     stream->write((VisualID*)&local_visualID, sizeof(VisualID));
@@ -12803,45 +12932,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_920;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_920, 1);
-        countingStream->write((uint64_t*)&cgen_var_920, 1 * 8);
+        uint64_t cgen_var_930;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_930, 1);
+        countingStream->write((uint64_t*)&cgen_var_930, 1 * 8);
         marshal_VkXcbSurfaceCreateInfoKHR(countingStream, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_921 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_921);
+        uint64_t cgen_var_931 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_931);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_922;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_922, 1);
-        countingStream->write((uint64_t*)&cgen_var_922, 8);
+        uint64_t cgen_var_932;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_932, 1);
+        countingStream->write((uint64_t*)&cgen_var_932, 8);
     }
     uint32_t packetSize_vkCreateXcbSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateXcbSurfaceKHR = OP_vkCreateXcbSurfaceKHR;
     stream->write(&opcode_vkCreateXcbSurfaceKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateXcbSurfaceKHR, sizeof(uint32_t));
-    uint64_t cgen_var_923;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_923, 1);
-    stream->write((uint64_t*)&cgen_var_923, 1 * 8);
+    uint64_t cgen_var_933;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_933, 1);
+    stream->write((uint64_t*)&cgen_var_933, 1 * 8);
     marshal_VkXcbSurfaceCreateInfoKHR(stream, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_924 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_924);
+    uint64_t cgen_var_934 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_934);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_925;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_925, 1);
-    stream->write((uint64_t*)&cgen_var_925, 8);
+    uint64_t cgen_var_935;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_935, 1);
+    stream->write((uint64_t*)&cgen_var_935, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_926;
-    stream->read((uint64_t*)&cgen_var_926, 8);
-    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_926, (VkSurfaceKHR*)pSurface, 1);
+    uint64_t cgen_var_936;
+    stream->read((uint64_t*)&cgen_var_936, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_936, (VkSurfaceKHR*)pSurface, 1);
     VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateXcbSurfaceKHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -12871,9 +13000,9 @@
     local_visual_id = visual_id;
     countingStream->rewind();
     {
-        uint64_t cgen_var_927;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_927, 1);
-        countingStream->write((uint64_t*)&cgen_var_927, 1 * 8);
+        uint64_t cgen_var_937;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_937, 1);
+        countingStream->write((uint64_t*)&cgen_var_937, 1 * 8);
         countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
         countingStream->write((xcb_connection_t*)connection, sizeof(xcb_connection_t));
         countingStream->write((xcb_visualid_t*)&local_visual_id, sizeof(xcb_visualid_t));
@@ -12883,9 +13012,9 @@
     uint32_t opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR = OP_vkGetPhysicalDeviceXcbPresentationSupportKHR;
     stream->write(&opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t));
-    uint64_t cgen_var_928;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_928, 1);
-    stream->write((uint64_t*)&cgen_var_928, 1 * 8);
+    uint64_t cgen_var_938;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_938, 1);
+    stream->write((uint64_t*)&cgen_var_938, 1 * 8);
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     stream->write((xcb_connection_t*)connection, sizeof(xcb_connection_t));
     stream->write((xcb_visualid_t*)&local_visual_id, sizeof(xcb_visualid_t));
@@ -12940,45 +13069,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_929;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_929, 1);
-        countingStream->write((uint64_t*)&cgen_var_929, 1 * 8);
+        uint64_t cgen_var_939;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_939, 1);
+        countingStream->write((uint64_t*)&cgen_var_939, 1 * 8);
         marshal_VkWaylandSurfaceCreateInfoKHR(countingStream, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_930 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_930);
+        uint64_t cgen_var_940 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_940);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_931;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_931, 1);
-        countingStream->write((uint64_t*)&cgen_var_931, 8);
+        uint64_t cgen_var_941;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_941, 1);
+        countingStream->write((uint64_t*)&cgen_var_941, 8);
     }
     uint32_t packetSize_vkCreateWaylandSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateWaylandSurfaceKHR = OP_vkCreateWaylandSurfaceKHR;
     stream->write(&opcode_vkCreateWaylandSurfaceKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateWaylandSurfaceKHR, sizeof(uint32_t));
-    uint64_t cgen_var_932;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_932, 1);
-    stream->write((uint64_t*)&cgen_var_932, 1 * 8);
+    uint64_t cgen_var_942;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_942, 1);
+    stream->write((uint64_t*)&cgen_var_942, 1 * 8);
     marshal_VkWaylandSurfaceCreateInfoKHR(stream, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_933 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_933);
+    uint64_t cgen_var_943 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_943);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_934;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_934, 1);
-    stream->write((uint64_t*)&cgen_var_934, 8);
+    uint64_t cgen_var_944;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_944, 1);
+    stream->write((uint64_t*)&cgen_var_944, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_935;
-    stream->read((uint64_t*)&cgen_var_935, 8);
-    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_935, (VkSurfaceKHR*)pSurface, 1);
+    uint64_t cgen_var_945;
+    stream->read((uint64_t*)&cgen_var_945, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_945, (VkSurfaceKHR*)pSurface, 1);
     VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateWaylandSurfaceKHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -13005,9 +13134,9 @@
     local_queueFamilyIndex = queueFamilyIndex;
     countingStream->rewind();
     {
-        uint64_t cgen_var_936;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_936, 1);
-        countingStream->write((uint64_t*)&cgen_var_936, 1 * 8);
+        uint64_t cgen_var_946;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_946, 1);
+        countingStream->write((uint64_t*)&cgen_var_946, 1 * 8);
         countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
         countingStream->write((wl_display*)display, sizeof(wl_display));
     }
@@ -13016,9 +13145,9 @@
     uint32_t opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR = OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR;
     stream->write(&opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t));
-    uint64_t cgen_var_937;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_937, 1);
-    stream->write((uint64_t*)&cgen_var_937, 1 * 8);
+    uint64_t cgen_var_947;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_947, 1);
+    stream->write((uint64_t*)&cgen_var_947, 1 * 8);
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     stream->write((wl_display*)display, sizeof(wl_display));
     stream->read((wl_display*)display, sizeof(wl_display));
@@ -13072,45 +13201,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_938;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_938, 1);
-        countingStream->write((uint64_t*)&cgen_var_938, 1 * 8);
+        uint64_t cgen_var_948;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_948, 1);
+        countingStream->write((uint64_t*)&cgen_var_948, 1 * 8);
         marshal_VkMirSurfaceCreateInfoKHR(countingStream, (VkMirSurfaceCreateInfoKHR*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_939 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_939);
+        uint64_t cgen_var_949 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_949);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_940;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_940, 1);
-        countingStream->write((uint64_t*)&cgen_var_940, 8);
+        uint64_t cgen_var_950;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_950, 1);
+        countingStream->write((uint64_t*)&cgen_var_950, 8);
     }
     uint32_t packetSize_vkCreateMirSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateMirSurfaceKHR = OP_vkCreateMirSurfaceKHR;
     stream->write(&opcode_vkCreateMirSurfaceKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateMirSurfaceKHR, sizeof(uint32_t));
-    uint64_t cgen_var_941;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_941, 1);
-    stream->write((uint64_t*)&cgen_var_941, 1 * 8);
+    uint64_t cgen_var_951;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_951, 1);
+    stream->write((uint64_t*)&cgen_var_951, 1 * 8);
     marshal_VkMirSurfaceCreateInfoKHR(stream, (VkMirSurfaceCreateInfoKHR*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_942 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_942);
+    uint64_t cgen_var_952 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_952);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_943;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_943, 1);
-    stream->write((uint64_t*)&cgen_var_943, 8);
+    uint64_t cgen_var_953;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_953, 1);
+    stream->write((uint64_t*)&cgen_var_953, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_944;
-    stream->read((uint64_t*)&cgen_var_944, 8);
-    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_944, (VkSurfaceKHR*)pSurface, 1);
+    uint64_t cgen_var_954;
+    stream->read((uint64_t*)&cgen_var_954, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_954, (VkSurfaceKHR*)pSurface, 1);
     VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateMirSurfaceKHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -13137,9 +13266,9 @@
     local_queueFamilyIndex = queueFamilyIndex;
     countingStream->rewind();
     {
-        uint64_t cgen_var_945;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_945, 1);
-        countingStream->write((uint64_t*)&cgen_var_945, 1 * 8);
+        uint64_t cgen_var_955;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_955, 1);
+        countingStream->write((uint64_t*)&cgen_var_955, 1 * 8);
         countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
         countingStream->write((MirConnection*)connection, sizeof(MirConnection));
     }
@@ -13148,9 +13277,9 @@
     uint32_t opcode_vkGetPhysicalDeviceMirPresentationSupportKHR = OP_vkGetPhysicalDeviceMirPresentationSupportKHR;
     stream->write(&opcode_vkGetPhysicalDeviceMirPresentationSupportKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceMirPresentationSupportKHR, sizeof(uint32_t));
-    uint64_t cgen_var_946;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_946, 1);
-    stream->write((uint64_t*)&cgen_var_946, 1 * 8);
+    uint64_t cgen_var_956;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_956, 1);
+    stream->write((uint64_t*)&cgen_var_956, 1 * 8);
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     stream->write((MirConnection*)connection, sizeof(MirConnection));
     stream->read((MirConnection*)connection, sizeof(MirConnection));
@@ -13204,45 +13333,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_947;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_947, 1);
-        countingStream->write((uint64_t*)&cgen_var_947, 1 * 8);
+        uint64_t cgen_var_957;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_957, 1);
+        countingStream->write((uint64_t*)&cgen_var_957, 1 * 8);
         marshal_VkAndroidSurfaceCreateInfoKHR(countingStream, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_948 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_948);
+        uint64_t cgen_var_958 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_958);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_949;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_949, 1);
-        countingStream->write((uint64_t*)&cgen_var_949, 8);
+        uint64_t cgen_var_959;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_959, 1);
+        countingStream->write((uint64_t*)&cgen_var_959, 8);
     }
     uint32_t packetSize_vkCreateAndroidSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateAndroidSurfaceKHR = OP_vkCreateAndroidSurfaceKHR;
     stream->write(&opcode_vkCreateAndroidSurfaceKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateAndroidSurfaceKHR, sizeof(uint32_t));
-    uint64_t cgen_var_950;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_950, 1);
-    stream->write((uint64_t*)&cgen_var_950, 1 * 8);
+    uint64_t cgen_var_960;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_960, 1);
+    stream->write((uint64_t*)&cgen_var_960, 1 * 8);
     marshal_VkAndroidSurfaceCreateInfoKHR(stream, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_951 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_951);
+    uint64_t cgen_var_961 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_961);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_952;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_952, 1);
-    stream->write((uint64_t*)&cgen_var_952, 8);
+    uint64_t cgen_var_962;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_962, 1);
+    stream->write((uint64_t*)&cgen_var_962, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_953;
-    stream->read((uint64_t*)&cgen_var_953, 8);
-    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_953, (VkSurfaceKHR*)pSurface, 1);
+    uint64_t cgen_var_963;
+    stream->read((uint64_t*)&cgen_var_963, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_963, (VkSurfaceKHR*)pSurface, 1);
     VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateAndroidSurfaceKHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -13293,45 +13422,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_954;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_954, 1);
-        countingStream->write((uint64_t*)&cgen_var_954, 1 * 8);
+        uint64_t cgen_var_964;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_964, 1);
+        countingStream->write((uint64_t*)&cgen_var_964, 1 * 8);
         marshal_VkWin32SurfaceCreateInfoKHR(countingStream, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_955 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_955);
+        uint64_t cgen_var_965 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_965);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_956;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_956, 1);
-        countingStream->write((uint64_t*)&cgen_var_956, 8);
+        uint64_t cgen_var_966;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_966, 1);
+        countingStream->write((uint64_t*)&cgen_var_966, 8);
     }
     uint32_t packetSize_vkCreateWin32SurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateWin32SurfaceKHR = OP_vkCreateWin32SurfaceKHR;
     stream->write(&opcode_vkCreateWin32SurfaceKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateWin32SurfaceKHR, sizeof(uint32_t));
-    uint64_t cgen_var_957;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_957, 1);
-    stream->write((uint64_t*)&cgen_var_957, 1 * 8);
+    uint64_t cgen_var_967;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_967, 1);
+    stream->write((uint64_t*)&cgen_var_967, 1 * 8);
     marshal_VkWin32SurfaceCreateInfoKHR(stream, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_958 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_958);
+    uint64_t cgen_var_968 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_968);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_959;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_959, 1);
-    stream->write((uint64_t*)&cgen_var_959, 8);
+    uint64_t cgen_var_969;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_969, 1);
+    stream->write((uint64_t*)&cgen_var_969, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_960;
-    stream->read((uint64_t*)&cgen_var_960, 8);
-    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_960, (VkSurfaceKHR*)pSurface, 1);
+    uint64_t cgen_var_970;
+    stream->read((uint64_t*)&cgen_var_970, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_970, (VkSurfaceKHR*)pSurface, 1);
     VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateWin32SurfaceKHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -13357,9 +13486,9 @@
     local_queueFamilyIndex = queueFamilyIndex;
     countingStream->rewind();
     {
-        uint64_t cgen_var_961;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_961, 1);
-        countingStream->write((uint64_t*)&cgen_var_961, 1 * 8);
+        uint64_t cgen_var_971;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_971, 1);
+        countingStream->write((uint64_t*)&cgen_var_971, 1 * 8);
         countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     }
     uint32_t packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -13367,9 +13496,9 @@
     uint32_t opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR = OP_vkGetPhysicalDeviceWin32PresentationSupportKHR;
     stream->write(&opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t));
-    uint64_t cgen_var_962;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_962, 1);
-    stream->write((uint64_t*)&cgen_var_962, 1 * 8);
+    uint64_t cgen_var_972;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_972, 1);
+    stream->write((uint64_t*)&cgen_var_972, 1 * 8);
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
@@ -13400,9 +13529,9 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_963;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_963, 1);
-        countingStream->write((uint64_t*)&cgen_var_963, 1 * 8);
+        uint64_t cgen_var_973;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_973, 1);
+        countingStream->write((uint64_t*)&cgen_var_973, 1 * 8);
         marshal_VkPhysicalDeviceFeatures2(countingStream, (VkPhysicalDeviceFeatures2*)(pFeatures));
     }
     uint32_t packetSize_vkGetPhysicalDeviceFeatures2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -13410,9 +13539,9 @@
     uint32_t opcode_vkGetPhysicalDeviceFeatures2KHR = OP_vkGetPhysicalDeviceFeatures2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_964;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_964, 1);
-    stream->write((uint64_t*)&cgen_var_964, 1 * 8);
+    uint64_t cgen_var_974;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_974, 1);
+    stream->write((uint64_t*)&cgen_var_974, 1 * 8);
     marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
     unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
     if (pFeatures)
@@ -13436,9 +13565,9 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_965;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_965, 1);
-        countingStream->write((uint64_t*)&cgen_var_965, 1 * 8);
+        uint64_t cgen_var_975;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_975, 1);
+        countingStream->write((uint64_t*)&cgen_var_975, 1 * 8);
         marshal_VkPhysicalDeviceProperties2(countingStream, (VkPhysicalDeviceProperties2*)(pProperties));
     }
     uint32_t packetSize_vkGetPhysicalDeviceProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -13446,9 +13575,9 @@
     uint32_t opcode_vkGetPhysicalDeviceProperties2KHR = OP_vkGetPhysicalDeviceProperties2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_966;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_966, 1);
-    stream->write((uint64_t*)&cgen_var_966, 1 * 8);
+    uint64_t cgen_var_976;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_976, 1);
+    stream->write((uint64_t*)&cgen_var_976, 1 * 8);
     marshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
     unmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
     if (pProperties)
@@ -13475,9 +13604,9 @@
     local_format = format;
     countingStream->rewind();
     {
-        uint64_t cgen_var_967;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_967, 1);
-        countingStream->write((uint64_t*)&cgen_var_967, 1 * 8);
+        uint64_t cgen_var_977;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_977, 1);
+        countingStream->write((uint64_t*)&cgen_var_977, 1 * 8);
         countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
         marshal_VkFormatProperties2(countingStream, (VkFormatProperties2*)(pFormatProperties));
     }
@@ -13486,9 +13615,9 @@
     uint32_t opcode_vkGetPhysicalDeviceFormatProperties2KHR = OP_vkGetPhysicalDeviceFormatProperties2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_968;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_968, 1);
-    stream->write((uint64_t*)&cgen_var_968, 1 * 8);
+    uint64_t cgen_var_978;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_978, 1);
+    stream->write((uint64_t*)&cgen_var_978, 1 * 8);
     stream->write((VkFormat*)&local_format, sizeof(VkFormat));
     marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
     unmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
@@ -13525,9 +13654,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_969;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_969, 1);
-        countingStream->write((uint64_t*)&cgen_var_969, 1 * 8);
+        uint64_t cgen_var_979;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_979, 1);
+        countingStream->write((uint64_t*)&cgen_var_979, 1 * 8);
         marshal_VkPhysicalDeviceImageFormatInfo2(countingStream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
         marshal_VkImageFormatProperties2(countingStream, (VkImageFormatProperties2*)(pImageFormatProperties));
     }
@@ -13536,9 +13665,9 @@
     uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2KHR = OP_vkGetPhysicalDeviceImageFormatProperties2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_970;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_970, 1);
-    stream->write((uint64_t*)&cgen_var_970, 1 * 8);
+    uint64_t cgen_var_980;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_980, 1);
+    stream->write((uint64_t*)&cgen_var_980, 1 * 8);
     marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
     marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
     unmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
@@ -13570,19 +13699,19 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_971;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_971, 1);
-        countingStream->write((uint64_t*)&cgen_var_971, 1 * 8);
+        uint64_t cgen_var_981;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_981, 1);
+        countingStream->write((uint64_t*)&cgen_var_981, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_972 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
-        countingStream->putBe64(cgen_var_972);
+        uint64_t cgen_var_982 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+        countingStream->putBe64(cgen_var_982);
         if (pQueueFamilyPropertyCount)
         {
             countingStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_973 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
-        countingStream->putBe64(cgen_var_973);
+        uint64_t cgen_var_983 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+        countingStream->putBe64(cgen_var_983);
         if (pQueueFamilyProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
@@ -13596,19 +13725,19 @@
     uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR = OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_974;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_974, 1);
-    stream->write((uint64_t*)&cgen_var_974, 1 * 8);
+    uint64_t cgen_var_984;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_984, 1);
+    stream->write((uint64_t*)&cgen_var_984, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_975 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
-    stream->putBe64(cgen_var_975);
+    uint64_t cgen_var_985 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+    stream->putBe64(cgen_var_985);
     if (pQueueFamilyPropertyCount)
     {
         stream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_976 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
-    stream->putBe64(cgen_var_976);
+    uint64_t cgen_var_986 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+    stream->putBe64(cgen_var_986);
     if (pQueueFamilyProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
@@ -13665,9 +13794,9 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_979;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_979, 1);
-        countingStream->write((uint64_t*)&cgen_var_979, 1 * 8);
+        uint64_t cgen_var_989;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_989, 1);
+        countingStream->write((uint64_t*)&cgen_var_989, 1 * 8);
         marshal_VkPhysicalDeviceMemoryProperties2(countingStream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     }
     uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -13675,15 +13804,16 @@
     uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2KHR = OP_vkGetPhysicalDeviceMemoryProperties2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_980;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_980, 1);
-    stream->write((uint64_t*)&cgen_var_980, 1 * 8);
+    uint64_t cgen_var_990;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_990, 1);
+    stream->write((uint64_t*)&cgen_var_990, 1 * 8);
     marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     if (pMemoryProperties)
     {
         transform_fromhost_VkPhysicalDeviceMemoryProperties2(mImpl->resources(), (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     }
+    mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties2KHR(this, physicalDevice, pMemoryProperties);
     mImpl->log("finish vkGetPhysicalDeviceMemoryProperties2KHR");;
 }
 
@@ -13714,20 +13844,20 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_981;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_981, 1);
-        countingStream->write((uint64_t*)&cgen_var_981, 1 * 8);
+        uint64_t cgen_var_991;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_991, 1);
+        countingStream->write((uint64_t*)&cgen_var_991, 1 * 8);
         marshal_VkPhysicalDeviceSparseImageFormatInfo2(countingStream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_982 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_982);
+        uint64_t cgen_var_992 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_992);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_983 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_983);
+        uint64_t cgen_var_993 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_993);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -13741,20 +13871,20 @@
     uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_984;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_984, 1);
-    stream->write((uint64_t*)&cgen_var_984, 1 * 8);
+    uint64_t cgen_var_994;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_994, 1);
+    stream->write((uint64_t*)&cgen_var_994, 1 * 8);
     marshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_985 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_985);
+    uint64_t cgen_var_995 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_995);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_986 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_986);
+    uint64_t cgen_var_996 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_996);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -13822,9 +13952,9 @@
     local_remoteDeviceIndex = remoteDeviceIndex;
     countingStream->rewind();
     {
-        uint64_t cgen_var_989;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_989, 1);
-        countingStream->write((uint64_t*)&cgen_var_989, 1 * 8);
+        uint64_t cgen_var_999;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_999, 1);
+        countingStream->write((uint64_t*)&cgen_var_999, 1 * 8);
         countingStream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
@@ -13835,9 +13965,9 @@
     uint32_t opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR = OP_vkGetDeviceGroupPeerMemoryFeaturesKHR;
     stream->write(&opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_990;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_990, 1);
-    stream->write((uint64_t*)&cgen_var_990, 1 * 8);
+    uint64_t cgen_var_1000;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1000, 1);
+    stream->write((uint64_t*)&cgen_var_1000, 1 * 8);
     stream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
     stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
     stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
@@ -13862,9 +13992,9 @@
     local_deviceMask = deviceMask;
     countingStream->rewind();
     {
-        uint64_t cgen_var_991;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_991, 1);
-        countingStream->write((uint64_t*)&cgen_var_991, 1 * 8);
+        uint64_t cgen_var_1001;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1001, 1);
+        countingStream->write((uint64_t*)&cgen_var_1001, 1 * 8);
         countingStream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
     }
     uint32_t packetSize_vkCmdSetDeviceMaskKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -13872,9 +14002,9 @@
     uint32_t opcode_vkCmdSetDeviceMaskKHR = OP_vkCmdSetDeviceMaskKHR;
     stream->write(&opcode_vkCmdSetDeviceMaskKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetDeviceMaskKHR, sizeof(uint32_t));
-    uint64_t cgen_var_992;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_992, 1);
-    stream->write((uint64_t*)&cgen_var_992, 1 * 8);
+    uint64_t cgen_var_1002;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1002, 1);
+    stream->write((uint64_t*)&cgen_var_1002, 1 * 8);
     stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
     mImpl->log("finish vkCmdSetDeviceMaskKHR");;
 }
@@ -13910,9 +14040,9 @@
     local_groupCountZ = groupCountZ;
     countingStream->rewind();
     {
-        uint64_t cgen_var_993;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_993, 1);
-        countingStream->write((uint64_t*)&cgen_var_993, 1 * 8);
+        uint64_t cgen_var_1003;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1003, 1);
+        countingStream->write((uint64_t*)&cgen_var_1003, 1 * 8);
         countingStream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
@@ -13925,9 +14055,9 @@
     uint32_t opcode_vkCmdDispatchBaseKHR = OP_vkCmdDispatchBaseKHR;
     stream->write(&opcode_vkCmdDispatchBaseKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDispatchBaseKHR, sizeof(uint32_t));
-    uint64_t cgen_var_994;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_994, 1);
-    stream->write((uint64_t*)&cgen_var_994, 1 * 8);
+    uint64_t cgen_var_1004;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1004, 1);
+    stream->write((uint64_t*)&cgen_var_1004, 1 * 8);
     stream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
     stream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
     stream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
@@ -13960,12 +14090,12 @@
     local_flags = flags;
     countingStream->rewind();
     {
-        uint64_t cgen_var_995;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_995, 1);
-        countingStream->write((uint64_t*)&cgen_var_995, 1 * 8);
-        uint64_t cgen_var_996;
-        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_996, 1);
-        countingStream->write((uint64_t*)&cgen_var_996, 1 * 8);
+        uint64_t cgen_var_1005;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1005, 1);
+        countingStream->write((uint64_t*)&cgen_var_1005, 1 * 8);
+        uint64_t cgen_var_1006;
+        countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_1006, 1);
+        countingStream->write((uint64_t*)&cgen_var_1006, 1 * 8);
         countingStream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
     }
     uint32_t packetSize_vkTrimCommandPoolKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -13973,12 +14103,12 @@
     uint32_t opcode_vkTrimCommandPoolKHR = OP_vkTrimCommandPoolKHR;
     stream->write(&opcode_vkTrimCommandPoolKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkTrimCommandPoolKHR, sizeof(uint32_t));
-    uint64_t cgen_var_997;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_997, 1);
-    stream->write((uint64_t*)&cgen_var_997, 1 * 8);
-    uint64_t cgen_var_998;
-    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_998, 1);
-    stream->write((uint64_t*)&cgen_var_998, 1 * 8);
+    uint64_t cgen_var_1007;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1007, 1);
+    stream->write((uint64_t*)&cgen_var_1007, 1 * 8);
+    uint64_t cgen_var_1008;
+    stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_1008, 1);
+    stream->write((uint64_t*)&cgen_var_1008, 1 * 8);
     stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
     mImpl->log("finish vkTrimCommandPoolKHR");;
 }
@@ -14000,19 +14130,19 @@
     local_instance = instance;
     countingStream->rewind();
     {
-        uint64_t cgen_var_999;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_999, 1);
-        countingStream->write((uint64_t*)&cgen_var_999, 1 * 8);
+        uint64_t cgen_var_1009;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1009, 1);
+        countingStream->write((uint64_t*)&cgen_var_1009, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1000 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
-        countingStream->putBe64(cgen_var_1000);
+        uint64_t cgen_var_1010 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+        countingStream->putBe64(cgen_var_1010);
         if (pPhysicalDeviceGroupCount)
         {
             countingStream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_1001 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
-        countingStream->putBe64(cgen_var_1001);
+        uint64_t cgen_var_1011 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+        countingStream->putBe64(cgen_var_1011);
         if (pPhysicalDeviceGroupProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
@@ -14026,19 +14156,19 @@
     uint32_t opcode_vkEnumeratePhysicalDeviceGroupsKHR = OP_vkEnumeratePhysicalDeviceGroupsKHR;
     stream->write(&opcode_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1002;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1002, 1);
-    stream->write((uint64_t*)&cgen_var_1002, 1 * 8);
+    uint64_t cgen_var_1012;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1012, 1);
+    stream->write((uint64_t*)&cgen_var_1012, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1003 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
-    stream->putBe64(cgen_var_1003);
+    uint64_t cgen_var_1013 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+    stream->putBe64(cgen_var_1013);
     if (pPhysicalDeviceGroupCount)
     {
         stream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_1004 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
-    stream->putBe64(cgen_var_1004);
+    uint64_t cgen_var_1014 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+    stream->putBe64(cgen_var_1014);
     if (pPhysicalDeviceGroupProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
@@ -14115,9 +14245,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1007;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1007, 1);
-        countingStream->write((uint64_t*)&cgen_var_1007, 1 * 8);
+        uint64_t cgen_var_1017;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1017, 1);
+        countingStream->write((uint64_t*)&cgen_var_1017, 1 * 8);
         marshal_VkPhysicalDeviceExternalBufferInfo(countingStream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
         marshal_VkExternalBufferProperties(countingStream, (VkExternalBufferProperties*)(pExternalBufferProperties));
     }
@@ -14126,9 +14256,9 @@
     uint32_t opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR = OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
     stream->write(&opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1008;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1008, 1);
-    stream->write((uint64_t*)&cgen_var_1008, 1 * 8);
+    uint64_t cgen_var_1018;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1018, 1);
+    stream->write((uint64_t*)&cgen_var_1018, 1 * 8);
     marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
     marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
     unmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
@@ -14169,9 +14299,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1009;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1009, 1);
-        countingStream->write((uint64_t*)&cgen_var_1009, 1 * 8);
+        uint64_t cgen_var_1019;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1019, 1);
+        countingStream->write((uint64_t*)&cgen_var_1019, 1 * 8);
         marshal_VkMemoryGetWin32HandleInfoKHR(countingStream, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
         countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
     }
@@ -14180,9 +14310,9 @@
     uint32_t opcode_vkGetMemoryWin32HandleKHR = OP_vkGetMemoryWin32HandleKHR;
     stream->write(&opcode_vkGetMemoryWin32HandleKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetMemoryWin32HandleKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1010;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1010, 1);
-    stream->write((uint64_t*)&cgen_var_1010, 1 * 8);
+    uint64_t cgen_var_1020;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1020, 1);
+    stream->write((uint64_t*)&cgen_var_1020, 1 * 8);
     marshal_VkMemoryGetWin32HandleInfoKHR(stream, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
     stream->write((HANDLE*)pHandle, sizeof(HANDLE));
     stream->read((HANDLE*)pHandle, sizeof(HANDLE));
@@ -14215,9 +14345,9 @@
     local_handle = handle;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1011;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1011, 1);
-        countingStream->write((uint64_t*)&cgen_var_1011, 1 * 8);
+        uint64_t cgen_var_1021;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1021, 1);
+        countingStream->write((uint64_t*)&cgen_var_1021, 1 * 8);
         countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
         countingStream->write((HANDLE*)&local_handle, sizeof(HANDLE));
         marshal_VkMemoryWin32HandlePropertiesKHR(countingStream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
@@ -14227,9 +14357,9 @@
     uint32_t opcode_vkGetMemoryWin32HandlePropertiesKHR = OP_vkGetMemoryWin32HandlePropertiesKHR;
     stream->write(&opcode_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1012;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1012, 1);
-    stream->write((uint64_t*)&cgen_var_1012, 1 * 8);
+    uint64_t cgen_var_1022;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1022, 1);
+    stream->write((uint64_t*)&cgen_var_1022, 1 * 8);
     stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
     stream->write((HANDLE*)&local_handle, sizeof(HANDLE));
     marshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
@@ -14275,9 +14405,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1013;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1013, 1);
-        countingStream->write((uint64_t*)&cgen_var_1013, 1 * 8);
+        uint64_t cgen_var_1023;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1023, 1);
+        countingStream->write((uint64_t*)&cgen_var_1023, 1 * 8);
         marshal_VkMemoryGetFdInfoKHR(countingStream, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
         countingStream->write((int*)pFd, sizeof(int));
     }
@@ -14286,9 +14416,9 @@
     uint32_t opcode_vkGetMemoryFdKHR = OP_vkGetMemoryFdKHR;
     stream->write(&opcode_vkGetMemoryFdKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetMemoryFdKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1014;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1014, 1);
-    stream->write((uint64_t*)&cgen_var_1014, 1 * 8);
+    uint64_t cgen_var_1024;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1024, 1);
+    stream->write((uint64_t*)&cgen_var_1024, 1 * 8);
     marshal_VkMemoryGetFdInfoKHR(stream, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
     stream->write((int*)pFd, sizeof(int));
     stream->read((int*)pFd, sizeof(int));
@@ -14321,9 +14451,9 @@
     local_fd = fd;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1015;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1015, 1);
-        countingStream->write((uint64_t*)&cgen_var_1015, 1 * 8);
+        uint64_t cgen_var_1025;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1025, 1);
+        countingStream->write((uint64_t*)&cgen_var_1025, 1 * 8);
         countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
         countingStream->write((int*)&local_fd, sizeof(int));
         marshal_VkMemoryFdPropertiesKHR(countingStream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
@@ -14333,9 +14463,9 @@
     uint32_t opcode_vkGetMemoryFdPropertiesKHR = OP_vkGetMemoryFdPropertiesKHR;
     stream->write(&opcode_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1016;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1016, 1);
-    stream->write((uint64_t*)&cgen_var_1016, 1 * 8);
+    uint64_t cgen_var_1026;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1026, 1);
+    stream->write((uint64_t*)&cgen_var_1026, 1 * 8);
     stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
     stream->write((int*)&local_fd, sizeof(int));
     marshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
@@ -14383,9 +14513,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1017;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1017, 1);
-        countingStream->write((uint64_t*)&cgen_var_1017, 1 * 8);
+        uint64_t cgen_var_1027;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1027, 1);
+        countingStream->write((uint64_t*)&cgen_var_1027, 1 * 8);
         marshal_VkPhysicalDeviceExternalSemaphoreInfo(countingStream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
         marshal_VkExternalSemaphoreProperties(countingStream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
     }
@@ -14394,9 +14524,9 @@
     uint32_t opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
     stream->write(&opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1018;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1018, 1);
-    stream->write((uint64_t*)&cgen_var_1018, 1 * 8);
+    uint64_t cgen_var_1028;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1028, 1);
+    stream->write((uint64_t*)&cgen_var_1028, 1 * 8);
     marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
     marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
     unmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
@@ -14436,9 +14566,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1019;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1019, 1);
-        countingStream->write((uint64_t*)&cgen_var_1019, 1 * 8);
+        uint64_t cgen_var_1029;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1029, 1);
+        countingStream->write((uint64_t*)&cgen_var_1029, 1 * 8);
         marshal_VkImportSemaphoreWin32HandleInfoKHR(countingStream, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
     }
     uint32_t packetSize_vkImportSemaphoreWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -14446,9 +14576,9 @@
     uint32_t opcode_vkImportSemaphoreWin32HandleKHR = OP_vkImportSemaphoreWin32HandleKHR;
     stream->write(&opcode_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1020;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1020, 1);
-    stream->write((uint64_t*)&cgen_var_1020, 1 * 8);
+    uint64_t cgen_var_1030;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1030, 1);
+    stream->write((uint64_t*)&cgen_var_1030, 1 * 8);
     marshal_VkImportSemaphoreWin32HandleInfoKHR(stream, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
     VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
@@ -14485,9 +14615,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1021;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1021, 1);
-        countingStream->write((uint64_t*)&cgen_var_1021, 1 * 8);
+        uint64_t cgen_var_1031;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1031, 1);
+        countingStream->write((uint64_t*)&cgen_var_1031, 1 * 8);
         marshal_VkSemaphoreGetWin32HandleInfoKHR(countingStream, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
         countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
     }
@@ -14496,9 +14626,9 @@
     uint32_t opcode_vkGetSemaphoreWin32HandleKHR = OP_vkGetSemaphoreWin32HandleKHR;
     stream->write(&opcode_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1022;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1022, 1);
-    stream->write((uint64_t*)&cgen_var_1022, 1 * 8);
+    uint64_t cgen_var_1032;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1032, 1);
+    stream->write((uint64_t*)&cgen_var_1032, 1 * 8);
     marshal_VkSemaphoreGetWin32HandleInfoKHR(stream, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
     stream->write((HANDLE*)pHandle, sizeof(HANDLE));
     stream->read((HANDLE*)pHandle, sizeof(HANDLE));
@@ -14538,9 +14668,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1023;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1023, 1);
-        countingStream->write((uint64_t*)&cgen_var_1023, 1 * 8);
+        uint64_t cgen_var_1033;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1033, 1);
+        countingStream->write((uint64_t*)&cgen_var_1033, 1 * 8);
         marshal_VkImportSemaphoreFdInfoKHR(countingStream, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
     }
     uint32_t packetSize_vkImportSemaphoreFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -14548,9 +14678,9 @@
     uint32_t opcode_vkImportSemaphoreFdKHR = OP_vkImportSemaphoreFdKHR;
     stream->write(&opcode_vkImportSemaphoreFdKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkImportSemaphoreFdKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1024;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1024, 1);
-    stream->write((uint64_t*)&cgen_var_1024, 1 * 8);
+    uint64_t cgen_var_1034;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1034, 1);
+    stream->write((uint64_t*)&cgen_var_1034, 1 * 8);
     marshal_VkImportSemaphoreFdInfoKHR(stream, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
     VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
@@ -14587,9 +14717,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1025;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1025, 1);
-        countingStream->write((uint64_t*)&cgen_var_1025, 1 * 8);
+        uint64_t cgen_var_1035;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1035, 1);
+        countingStream->write((uint64_t*)&cgen_var_1035, 1 * 8);
         marshal_VkSemaphoreGetFdInfoKHR(countingStream, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
         countingStream->write((int*)pFd, sizeof(int));
     }
@@ -14598,9 +14728,9 @@
     uint32_t opcode_vkGetSemaphoreFdKHR = OP_vkGetSemaphoreFdKHR;
     stream->write(&opcode_vkGetSemaphoreFdKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetSemaphoreFdKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1026;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1026, 1);
-    stream->write((uint64_t*)&cgen_var_1026, 1 * 8);
+    uint64_t cgen_var_1036;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1036, 1);
+    stream->write((uint64_t*)&cgen_var_1036, 1 * 8);
     marshal_VkSemaphoreGetFdInfoKHR(stream, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
     stream->write((int*)pFd, sizeof(int));
     stream->read((int*)pFd, sizeof(int));
@@ -14658,13 +14788,13 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1027;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1027, 1);
-        countingStream->write((uint64_t*)&cgen_var_1027, 1 * 8);
+        uint64_t cgen_var_1037;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1037, 1);
+        countingStream->write((uint64_t*)&cgen_var_1037, 1 * 8);
         countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
-        uint64_t cgen_var_1028;
-        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1028, 1);
-        countingStream->write((uint64_t*)&cgen_var_1028, 1 * 8);
+        uint64_t cgen_var_1038;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1038, 1);
+        countingStream->write((uint64_t*)&cgen_var_1038, 1 * 8);
         countingStream->write((uint32_t*)&local_set, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
@@ -14677,13 +14807,13 @@
     uint32_t opcode_vkCmdPushDescriptorSetKHR = OP_vkCmdPushDescriptorSetKHR;
     stream->write(&opcode_vkCmdPushDescriptorSetKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdPushDescriptorSetKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1029;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1029, 1);
-    stream->write((uint64_t*)&cgen_var_1029, 1 * 8);
+    uint64_t cgen_var_1039;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1039, 1);
+    stream->write((uint64_t*)&cgen_var_1039, 1 * 8);
     stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
-    uint64_t cgen_var_1030;
-    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1030, 1);
-    stream->write((uint64_t*)&cgen_var_1030, 1 * 8);
+    uint64_t cgen_var_1040;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1040, 1);
+    stream->write((uint64_t*)&cgen_var_1040, 1 * 8);
     stream->write((uint32_t*)&local_set, sizeof(uint32_t));
     stream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
@@ -14722,19 +14852,19 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1031;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1031, 1);
-        countingStream->write((uint64_t*)&cgen_var_1031, 1 * 8);
-        uint64_t cgen_var_1032;
-        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1032, 1);
-        countingStream->write((uint64_t*)&cgen_var_1032, 1 * 8);
-        uint64_t cgen_var_1033;
-        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1033, 1);
-        countingStream->write((uint64_t*)&cgen_var_1033, 1 * 8);
+        uint64_t cgen_var_1041;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1041, 1);
+        countingStream->write((uint64_t*)&cgen_var_1041, 1 * 8);
+        uint64_t cgen_var_1042;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1042, 1);
+        countingStream->write((uint64_t*)&cgen_var_1042, 1 * 8);
+        uint64_t cgen_var_1043;
+        countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1043, 1);
+        countingStream->write((uint64_t*)&cgen_var_1043, 1 * 8);
         countingStream->write((uint32_t*)&local_set, sizeof(uint32_t));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1034 = (uint64_t)(uintptr_t)local_pData;
-        countingStream->putBe64(cgen_var_1034);
+        uint64_t cgen_var_1044 = (uint64_t)(uintptr_t)local_pData;
+        countingStream->putBe64(cgen_var_1044);
         if (local_pData)
         {
             countingStream->write((void*)local_pData, sizeof(uint8_t));
@@ -14745,19 +14875,19 @@
     uint32_t opcode_vkCmdPushDescriptorSetWithTemplateKHR = OP_vkCmdPushDescriptorSetWithTemplateKHR;
     stream->write(&opcode_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1035;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1035, 1);
-    stream->write((uint64_t*)&cgen_var_1035, 1 * 8);
-    uint64_t cgen_var_1036;
-    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1036, 1);
-    stream->write((uint64_t*)&cgen_var_1036, 1 * 8);
-    uint64_t cgen_var_1037;
-    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1037, 1);
-    stream->write((uint64_t*)&cgen_var_1037, 1 * 8);
+    uint64_t cgen_var_1045;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1045, 1);
+    stream->write((uint64_t*)&cgen_var_1045, 1 * 8);
+    uint64_t cgen_var_1046;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1046, 1);
+    stream->write((uint64_t*)&cgen_var_1046, 1 * 8);
+    uint64_t cgen_var_1047;
+    stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1047, 1);
+    stream->write((uint64_t*)&cgen_var_1047, 1 * 8);
     stream->write((uint32_t*)&local_set, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1038 = (uint64_t)(uintptr_t)local_pData;
-    stream->putBe64(cgen_var_1038);
+    uint64_t cgen_var_1048 = (uint64_t)(uintptr_t)local_pData;
+    stream->putBe64(cgen_var_1048);
     if (local_pData)
     {
         stream->write((void*)local_pData, sizeof(uint8_t));
@@ -14810,45 +14940,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1039;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1039, 1);
-        countingStream->write((uint64_t*)&cgen_var_1039, 1 * 8);
+        uint64_t cgen_var_1049;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1049, 1);
+        countingStream->write((uint64_t*)&cgen_var_1049, 1 * 8);
         marshal_VkDescriptorUpdateTemplateCreateInfo(countingStream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1040 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1040);
+        uint64_t cgen_var_1050 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1050);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1041;
-        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1041, 1);
-        countingStream->write((uint64_t*)&cgen_var_1041, 8);
+        uint64_t cgen_var_1051;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1051, 1);
+        countingStream->write((uint64_t*)&cgen_var_1051, 8);
     }
     uint32_t packetSize_vkCreateDescriptorUpdateTemplateKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateDescriptorUpdateTemplateKHR = OP_vkCreateDescriptorUpdateTemplateKHR;
     stream->write(&opcode_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1042;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1042, 1);
-    stream->write((uint64_t*)&cgen_var_1042, 1 * 8);
+    uint64_t cgen_var_1052;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1052, 1);
+    stream->write((uint64_t*)&cgen_var_1052, 1 * 8);
     marshal_VkDescriptorUpdateTemplateCreateInfo(stream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1043 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1043);
+    uint64_t cgen_var_1053 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1053);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1044;
-    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1044, 1);
-    stream->write((uint64_t*)&cgen_var_1044, 8);
+    uint64_t cgen_var_1054;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1054, 1);
+    stream->write((uint64_t*)&cgen_var_1054, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_1045;
-    stream->read((uint64_t*)&cgen_var_1045, 8);
-    stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_1045, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
+    uint64_t cgen_var_1055;
+    stream->read((uint64_t*)&cgen_var_1055, 8);
+    stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_1055, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
     VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorUpdateTemplateKHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -14887,15 +15017,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1046;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1046, 1);
-        countingStream->write((uint64_t*)&cgen_var_1046, 1 * 8);
-        uint64_t cgen_var_1047;
-        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1047, 1);
-        countingStream->write((uint64_t*)&cgen_var_1047, 1 * 8);
+        uint64_t cgen_var_1056;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1056, 1);
+        countingStream->write((uint64_t*)&cgen_var_1056, 1 * 8);
+        uint64_t cgen_var_1057;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1057, 1);
+        countingStream->write((uint64_t*)&cgen_var_1057, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1048 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1048);
+        uint64_t cgen_var_1058 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1058);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -14906,15 +15036,15 @@
     uint32_t opcode_vkDestroyDescriptorUpdateTemplateKHR = OP_vkDestroyDescriptorUpdateTemplateKHR;
     stream->write(&opcode_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1049;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1049, 1);
-    stream->write((uint64_t*)&cgen_var_1049, 1 * 8);
-    uint64_t cgen_var_1050;
-    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1050, 1);
-    stream->write((uint64_t*)&cgen_var_1050, 1 * 8);
+    uint64_t cgen_var_1059;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1059, 1);
+    stream->write((uint64_t*)&cgen_var_1059, 1 * 8);
+    uint64_t cgen_var_1060;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1060, 1);
+    stream->write((uint64_t*)&cgen_var_1060, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1051 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1051);
+    uint64_t cgen_var_1061 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1061);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -14948,18 +15078,18 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1052;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1052, 1);
-        countingStream->write((uint64_t*)&cgen_var_1052, 1 * 8);
-        uint64_t cgen_var_1053;
-        countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1053, 1);
-        countingStream->write((uint64_t*)&cgen_var_1053, 1 * 8);
-        uint64_t cgen_var_1054;
-        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1054, 1);
-        countingStream->write((uint64_t*)&cgen_var_1054, 1 * 8);
+        uint64_t cgen_var_1062;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1062, 1);
+        countingStream->write((uint64_t*)&cgen_var_1062, 1 * 8);
+        uint64_t cgen_var_1063;
+        countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1063, 1);
+        countingStream->write((uint64_t*)&cgen_var_1063, 1 * 8);
+        uint64_t cgen_var_1064;
+        countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1064, 1);
+        countingStream->write((uint64_t*)&cgen_var_1064, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1055 = (uint64_t)(uintptr_t)local_pData;
-        countingStream->putBe64(cgen_var_1055);
+        uint64_t cgen_var_1065 = (uint64_t)(uintptr_t)local_pData;
+        countingStream->putBe64(cgen_var_1065);
         if (local_pData)
         {
             countingStream->write((void*)local_pData, sizeof(uint8_t));
@@ -14970,18 +15100,18 @@
     uint32_t opcode_vkUpdateDescriptorSetWithTemplateKHR = OP_vkUpdateDescriptorSetWithTemplateKHR;
     stream->write(&opcode_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1056;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1056, 1);
-    stream->write((uint64_t*)&cgen_var_1056, 1 * 8);
-    uint64_t cgen_var_1057;
-    stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1057, 1);
-    stream->write((uint64_t*)&cgen_var_1057, 1 * 8);
-    uint64_t cgen_var_1058;
-    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1058, 1);
-    stream->write((uint64_t*)&cgen_var_1058, 1 * 8);
+    uint64_t cgen_var_1066;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1066, 1);
+    stream->write((uint64_t*)&cgen_var_1066, 1 * 8);
+    uint64_t cgen_var_1067;
+    stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1067, 1);
+    stream->write((uint64_t*)&cgen_var_1067, 1 * 8);
+    uint64_t cgen_var_1068;
+    stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1068, 1);
+    stream->write((uint64_t*)&cgen_var_1068, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1059 = (uint64_t)(uintptr_t)local_pData;
-    stream->putBe64(cgen_var_1059);
+    uint64_t cgen_var_1069 = (uint64_t)(uintptr_t)local_pData;
+    stream->putBe64(cgen_var_1069);
     if (local_pData)
     {
         stream->write((void*)local_pData, sizeof(uint8_t));
@@ -15030,45 +15160,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1060;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1060, 1);
-        countingStream->write((uint64_t*)&cgen_var_1060, 1 * 8);
+        uint64_t cgen_var_1070;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1070, 1);
+        countingStream->write((uint64_t*)&cgen_var_1070, 1 * 8);
         marshal_VkRenderPassCreateInfo2KHR(countingStream, (VkRenderPassCreateInfo2KHR*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1061 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1061);
+        uint64_t cgen_var_1071 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1071);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1062;
-        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1062, 1);
-        countingStream->write((uint64_t*)&cgen_var_1062, 8);
+        uint64_t cgen_var_1072;
+        countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1072, 1);
+        countingStream->write((uint64_t*)&cgen_var_1072, 8);
     }
     uint32_t packetSize_vkCreateRenderPass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateRenderPass2KHR = OP_vkCreateRenderPass2KHR;
     stream->write(&opcode_vkCreateRenderPass2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateRenderPass2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1063;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1063, 1);
-    stream->write((uint64_t*)&cgen_var_1063, 1 * 8);
+    uint64_t cgen_var_1073;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1073, 1);
+    stream->write((uint64_t*)&cgen_var_1073, 1 * 8);
     marshal_VkRenderPassCreateInfo2KHR(stream, (VkRenderPassCreateInfo2KHR*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1064 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1064);
+    uint64_t cgen_var_1074 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1074);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1065;
-    stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1065, 1);
-    stream->write((uint64_t*)&cgen_var_1065, 8);
+    uint64_t cgen_var_1075;
+    stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1075, 1);
+    stream->write((uint64_t*)&cgen_var_1075, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_1066;
-    stream->read((uint64_t*)&cgen_var_1066, 8);
-    stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_1066, (VkRenderPass*)pRenderPass, 1);
+    uint64_t cgen_var_1076;
+    stream->read((uint64_t*)&cgen_var_1076, 8);
+    stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_1076, (VkRenderPass*)pRenderPass, 1);
     VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateRenderPass2KHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -15115,9 +15245,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1067;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1067, 1);
-        countingStream->write((uint64_t*)&cgen_var_1067, 1 * 8);
+        uint64_t cgen_var_1077;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1077, 1);
+        countingStream->write((uint64_t*)&cgen_var_1077, 1 * 8);
         marshal_VkRenderPassBeginInfo(countingStream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
         marshal_VkSubpassBeginInfoKHR(countingStream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
     }
@@ -15126,9 +15256,9 @@
     uint32_t opcode_vkCmdBeginRenderPass2KHR = OP_vkCmdBeginRenderPass2KHR;
     stream->write(&opcode_vkCmdBeginRenderPass2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdBeginRenderPass2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1068;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1068, 1);
-    stream->write((uint64_t*)&cgen_var_1068, 1 * 8);
+    uint64_t cgen_var_1078;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1078, 1);
+    stream->write((uint64_t*)&cgen_var_1078, 1 * 8);
     marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
     marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
     mImpl->log("finish vkCmdBeginRenderPass2KHR");;
@@ -15171,9 +15301,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1069;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1069, 1);
-        countingStream->write((uint64_t*)&cgen_var_1069, 1 * 8);
+        uint64_t cgen_var_1079;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1079, 1);
+        countingStream->write((uint64_t*)&cgen_var_1079, 1 * 8);
         marshal_VkSubpassBeginInfoKHR(countingStream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
         marshal_VkSubpassEndInfoKHR(countingStream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
     }
@@ -15182,9 +15312,9 @@
     uint32_t opcode_vkCmdNextSubpass2KHR = OP_vkCmdNextSubpass2KHR;
     stream->write(&opcode_vkCmdNextSubpass2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdNextSubpass2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1070;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1070, 1);
-    stream->write((uint64_t*)&cgen_var_1070, 1 * 8);
+    uint64_t cgen_var_1080;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1080, 1);
+    stream->write((uint64_t*)&cgen_var_1080, 1 * 8);
     marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
     marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
     mImpl->log("finish vkCmdNextSubpass2KHR");;
@@ -15215,9 +15345,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1071;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1071, 1);
-        countingStream->write((uint64_t*)&cgen_var_1071, 1 * 8);
+        uint64_t cgen_var_1081;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1081, 1);
+        countingStream->write((uint64_t*)&cgen_var_1081, 1 * 8);
         marshal_VkSubpassEndInfoKHR(countingStream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
     }
     uint32_t packetSize_vkCmdEndRenderPass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -15225,9 +15355,9 @@
     uint32_t opcode_vkCmdEndRenderPass2KHR = OP_vkCmdEndRenderPass2KHR;
     stream->write(&opcode_vkCmdEndRenderPass2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdEndRenderPass2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1072;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1072, 1);
-    stream->write((uint64_t*)&cgen_var_1072, 1 * 8);
+    uint64_t cgen_var_1082;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1082, 1);
+    stream->write((uint64_t*)&cgen_var_1082, 1 * 8);
     marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
     mImpl->log("finish vkCmdEndRenderPass2KHR");;
 }
@@ -15250,24 +15380,24 @@
     local_swapchain = swapchain;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1073;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1073, 1);
-        countingStream->write((uint64_t*)&cgen_var_1073, 1 * 8);
-        uint64_t cgen_var_1074;
-        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1074, 1);
-        countingStream->write((uint64_t*)&cgen_var_1074, 1 * 8);
+        uint64_t cgen_var_1083;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1083, 1);
+        countingStream->write((uint64_t*)&cgen_var_1083, 1 * 8);
+        uint64_t cgen_var_1084;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1084, 1);
+        countingStream->write((uint64_t*)&cgen_var_1084, 1 * 8);
     }
     uint32_t packetSize_vkGetSwapchainStatusKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkGetSwapchainStatusKHR = OP_vkGetSwapchainStatusKHR;
     stream->write(&opcode_vkGetSwapchainStatusKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetSwapchainStatusKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1075;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1075, 1);
-    stream->write((uint64_t*)&cgen_var_1075, 1 * 8);
-    uint64_t cgen_var_1076;
-    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1076, 1);
-    stream->write((uint64_t*)&cgen_var_1076, 1 * 8);
+    uint64_t cgen_var_1085;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1085, 1);
+    stream->write((uint64_t*)&cgen_var_1085, 1 * 8);
+    uint64_t cgen_var_1086;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1086, 1);
+    stream->write((uint64_t*)&cgen_var_1086, 1 * 8);
     VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetSwapchainStatusKHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -15305,9 +15435,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1077;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1077, 1);
-        countingStream->write((uint64_t*)&cgen_var_1077, 1 * 8);
+        uint64_t cgen_var_1087;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1087, 1);
+        countingStream->write((uint64_t*)&cgen_var_1087, 1 * 8);
         marshal_VkPhysicalDeviceExternalFenceInfo(countingStream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
         marshal_VkExternalFenceProperties(countingStream, (VkExternalFenceProperties*)(pExternalFenceProperties));
     }
@@ -15316,9 +15446,9 @@
     uint32_t opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR = OP_vkGetPhysicalDeviceExternalFencePropertiesKHR;
     stream->write(&opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1078;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1078, 1);
-    stream->write((uint64_t*)&cgen_var_1078, 1 * 8);
+    uint64_t cgen_var_1088;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1088, 1);
+    stream->write((uint64_t*)&cgen_var_1088, 1 * 8);
     marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
     marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
     unmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
@@ -15358,9 +15488,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1079;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1079, 1);
-        countingStream->write((uint64_t*)&cgen_var_1079, 1 * 8);
+        uint64_t cgen_var_1089;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1089, 1);
+        countingStream->write((uint64_t*)&cgen_var_1089, 1 * 8);
         marshal_VkImportFenceWin32HandleInfoKHR(countingStream, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
     }
     uint32_t packetSize_vkImportFenceWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -15368,9 +15498,9 @@
     uint32_t opcode_vkImportFenceWin32HandleKHR = OP_vkImportFenceWin32HandleKHR;
     stream->write(&opcode_vkImportFenceWin32HandleKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkImportFenceWin32HandleKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1080;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1080, 1);
-    stream->write((uint64_t*)&cgen_var_1080, 1 * 8);
+    uint64_t cgen_var_1090;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1090, 1);
+    stream->write((uint64_t*)&cgen_var_1090, 1 * 8);
     marshal_VkImportFenceWin32HandleInfoKHR(stream, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
     VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
@@ -15407,9 +15537,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1081;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1081, 1);
-        countingStream->write((uint64_t*)&cgen_var_1081, 1 * 8);
+        uint64_t cgen_var_1091;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1091, 1);
+        countingStream->write((uint64_t*)&cgen_var_1091, 1 * 8);
         marshal_VkFenceGetWin32HandleInfoKHR(countingStream, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
         countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
     }
@@ -15418,9 +15548,9 @@
     uint32_t opcode_vkGetFenceWin32HandleKHR = OP_vkGetFenceWin32HandleKHR;
     stream->write(&opcode_vkGetFenceWin32HandleKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetFenceWin32HandleKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1082;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1082, 1);
-    stream->write((uint64_t*)&cgen_var_1082, 1 * 8);
+    uint64_t cgen_var_1092;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1092, 1);
+    stream->write((uint64_t*)&cgen_var_1092, 1 * 8);
     marshal_VkFenceGetWin32HandleInfoKHR(stream, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
     stream->write((HANDLE*)pHandle, sizeof(HANDLE));
     stream->read((HANDLE*)pHandle, sizeof(HANDLE));
@@ -15460,9 +15590,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1083;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1083, 1);
-        countingStream->write((uint64_t*)&cgen_var_1083, 1 * 8);
+        uint64_t cgen_var_1093;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1093, 1);
+        countingStream->write((uint64_t*)&cgen_var_1093, 1 * 8);
         marshal_VkImportFenceFdInfoKHR(countingStream, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
     }
     uint32_t packetSize_vkImportFenceFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -15470,9 +15600,9 @@
     uint32_t opcode_vkImportFenceFdKHR = OP_vkImportFenceFdKHR;
     stream->write(&opcode_vkImportFenceFdKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkImportFenceFdKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1084;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1084, 1);
-    stream->write((uint64_t*)&cgen_var_1084, 1 * 8);
+    uint64_t cgen_var_1094;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1094, 1);
+    stream->write((uint64_t*)&cgen_var_1094, 1 * 8);
     marshal_VkImportFenceFdInfoKHR(stream, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
     VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportFenceFdKHR_VkResult_return, sizeof(VkResult));
@@ -15509,9 +15639,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1085;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1085, 1);
-        countingStream->write((uint64_t*)&cgen_var_1085, 1 * 8);
+        uint64_t cgen_var_1095;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1095, 1);
+        countingStream->write((uint64_t*)&cgen_var_1095, 1 * 8);
         marshal_VkFenceGetFdInfoKHR(countingStream, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
         countingStream->write((int*)pFd, sizeof(int));
     }
@@ -15520,9 +15650,9 @@
     uint32_t opcode_vkGetFenceFdKHR = OP_vkGetFenceFdKHR;
     stream->write(&opcode_vkGetFenceFdKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetFenceFdKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1086;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1086, 1);
-    stream->write((uint64_t*)&cgen_var_1086, 1 * 8);
+    uint64_t cgen_var_1096;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1096, 1);
+    stream->write((uint64_t*)&cgen_var_1096, 1 * 8);
     marshal_VkFenceGetFdInfoKHR(stream, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
     stream->write((int*)pFd, sizeof(int));
     stream->read((int*)pFd, sizeof(int));
@@ -15565,9 +15695,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1087;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1087, 1);
-        countingStream->write((uint64_t*)&cgen_var_1087, 1 * 8);
+        uint64_t cgen_var_1097;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1097, 1);
+        countingStream->write((uint64_t*)&cgen_var_1097, 1 * 8);
         marshal_VkPhysicalDeviceSurfaceInfo2KHR(countingStream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
         marshal_VkSurfaceCapabilities2KHR(countingStream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
     }
@@ -15576,9 +15706,9 @@
     uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR = OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1088;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1088, 1);
-    stream->write((uint64_t*)&cgen_var_1088, 1 * 8);
+    uint64_t cgen_var_1098;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1098, 1);
+    stream->write((uint64_t*)&cgen_var_1098, 1 * 8);
     marshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
     marshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
     unmarshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
@@ -15622,20 +15752,20 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1089;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1089, 1);
-        countingStream->write((uint64_t*)&cgen_var_1089, 1 * 8);
+        uint64_t cgen_var_1099;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1099, 1);
+        countingStream->write((uint64_t*)&cgen_var_1099, 1 * 8);
         marshal_VkPhysicalDeviceSurfaceInfo2KHR(countingStream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1090 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
-        countingStream->putBe64(cgen_var_1090);
+        uint64_t cgen_var_1100 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+        countingStream->putBe64(cgen_var_1100);
         if (pSurfaceFormatCount)
         {
             countingStream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_1091 = (uint64_t)(uintptr_t)pSurfaceFormats;
-        countingStream->putBe64(cgen_var_1091);
+        uint64_t cgen_var_1101 = (uint64_t)(uintptr_t)pSurfaceFormats;
+        countingStream->putBe64(cgen_var_1101);
         if (pSurfaceFormats)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
@@ -15649,20 +15779,20 @@
     uint32_t opcode_vkGetPhysicalDeviceSurfaceFormats2KHR = OP_vkGetPhysicalDeviceSurfaceFormats2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1092;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1092, 1);
-    stream->write((uint64_t*)&cgen_var_1092, 1 * 8);
+    uint64_t cgen_var_1102;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1102, 1);
+    stream->write((uint64_t*)&cgen_var_1102, 1 * 8);
     marshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1093 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
-    stream->putBe64(cgen_var_1093);
+    uint64_t cgen_var_1103 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+    stream->putBe64(cgen_var_1103);
     if (pSurfaceFormatCount)
     {
         stream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_1094 = (uint64_t)(uintptr_t)pSurfaceFormats;
-    stream->putBe64(cgen_var_1094);
+    uint64_t cgen_var_1104 = (uint64_t)(uintptr_t)pSurfaceFormats;
+    stream->putBe64(cgen_var_1104);
     if (pSurfaceFormats)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
@@ -15730,19 +15860,19 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1097;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1097, 1);
-        countingStream->write((uint64_t*)&cgen_var_1097, 1 * 8);
+        uint64_t cgen_var_1107;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1107, 1);
+        countingStream->write((uint64_t*)&cgen_var_1107, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1098 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_1098);
+        uint64_t cgen_var_1108 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_1108);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_1099 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_1099);
+        uint64_t cgen_var_1109 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_1109);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -15756,19 +15886,19 @@
     uint32_t opcode_vkGetPhysicalDeviceDisplayProperties2KHR = OP_vkGetPhysicalDeviceDisplayProperties2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1100;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1100, 1);
-    stream->write((uint64_t*)&cgen_var_1100, 1 * 8);
+    uint64_t cgen_var_1110;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1110, 1);
+    stream->write((uint64_t*)&cgen_var_1110, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1101 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_1101);
+    uint64_t cgen_var_1111 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_1111);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_1102 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_1102);
+    uint64_t cgen_var_1112 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_1112);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -15832,19 +15962,19 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1105;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1105, 1);
-        countingStream->write((uint64_t*)&cgen_var_1105, 1 * 8);
+        uint64_t cgen_var_1115;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1115, 1);
+        countingStream->write((uint64_t*)&cgen_var_1115, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1106 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_1106);
+        uint64_t cgen_var_1116 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_1116);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_1107 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_1107);
+        uint64_t cgen_var_1117 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_1117);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -15858,19 +15988,19 @@
     uint32_t opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
     stream->write(&opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1108;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1108, 1);
-    stream->write((uint64_t*)&cgen_var_1108, 1 * 8);
+    uint64_t cgen_var_1118;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1118, 1);
+    stream->write((uint64_t*)&cgen_var_1118, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1109 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_1109);
+    uint64_t cgen_var_1119 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_1119);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_1110 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_1110);
+    uint64_t cgen_var_1120 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_1120);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -15937,22 +16067,22 @@
     local_display = display;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1113;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1113, 1);
-        countingStream->write((uint64_t*)&cgen_var_1113, 1 * 8);
-        uint64_t cgen_var_1114;
-        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1114, 1);
-        countingStream->write((uint64_t*)&cgen_var_1114, 1 * 8);
+        uint64_t cgen_var_1123;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1123, 1);
+        countingStream->write((uint64_t*)&cgen_var_1123, 1 * 8);
+        uint64_t cgen_var_1124;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1124, 1);
+        countingStream->write((uint64_t*)&cgen_var_1124, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1115 = (uint64_t)(uintptr_t)pPropertyCount;
-        countingStream->putBe64(cgen_var_1115);
+        uint64_t cgen_var_1125 = (uint64_t)(uintptr_t)pPropertyCount;
+        countingStream->putBe64(cgen_var_1125);
         if (pPropertyCount)
         {
             countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_1116 = (uint64_t)(uintptr_t)pProperties;
-        countingStream->putBe64(cgen_var_1116);
+        uint64_t cgen_var_1126 = (uint64_t)(uintptr_t)pProperties;
+        countingStream->putBe64(cgen_var_1126);
         if (pProperties)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -15966,22 +16096,22 @@
     uint32_t opcode_vkGetDisplayModeProperties2KHR = OP_vkGetDisplayModeProperties2KHR;
     stream->write(&opcode_vkGetDisplayModeProperties2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDisplayModeProperties2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1117;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1117, 1);
-    stream->write((uint64_t*)&cgen_var_1117, 1 * 8);
-    uint64_t cgen_var_1118;
-    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1118, 1);
-    stream->write((uint64_t*)&cgen_var_1118, 1 * 8);
+    uint64_t cgen_var_1127;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1127, 1);
+    stream->write((uint64_t*)&cgen_var_1127, 1 * 8);
+    uint64_t cgen_var_1128;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1128, 1);
+    stream->write((uint64_t*)&cgen_var_1128, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1119 = (uint64_t)(uintptr_t)pPropertyCount;
-    stream->putBe64(cgen_var_1119);
+    uint64_t cgen_var_1129 = (uint64_t)(uintptr_t)pPropertyCount;
+    stream->putBe64(cgen_var_1129);
     if (pPropertyCount)
     {
         stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_1120 = (uint64_t)(uintptr_t)pProperties;
-    stream->putBe64(cgen_var_1120);
+    uint64_t cgen_var_1130 = (uint64_t)(uintptr_t)pProperties;
+    stream->putBe64(cgen_var_1130);
     if (pProperties)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -16056,9 +16186,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1123;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1123, 1);
-        countingStream->write((uint64_t*)&cgen_var_1123, 1 * 8);
+        uint64_t cgen_var_1133;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1133, 1);
+        countingStream->write((uint64_t*)&cgen_var_1133, 1 * 8);
         marshal_VkDisplayPlaneInfo2KHR(countingStream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
         marshal_VkDisplayPlaneCapabilities2KHR(countingStream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
     }
@@ -16067,9 +16197,9 @@
     uint32_t opcode_vkGetDisplayPlaneCapabilities2KHR = OP_vkGetDisplayPlaneCapabilities2KHR;
     stream->write(&opcode_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1124;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1124, 1);
-    stream->write((uint64_t*)&cgen_var_1124, 1 * 8);
+    uint64_t cgen_var_1134;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1134, 1);
+    stream->write((uint64_t*)&cgen_var_1134, 1 * 8);
     marshal_VkDisplayPlaneInfo2KHR(stream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
     marshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
     unmarshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
@@ -16120,9 +16250,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1125;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1125, 1);
-        countingStream->write((uint64_t*)&cgen_var_1125, 1 * 8);
+        uint64_t cgen_var_1135;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1135, 1);
+        countingStream->write((uint64_t*)&cgen_var_1135, 1 * 8);
         marshal_VkImageMemoryRequirementsInfo2(countingStream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
         marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
     }
@@ -16131,9 +16261,9 @@
     uint32_t opcode_vkGetImageMemoryRequirements2KHR = OP_vkGetImageMemoryRequirements2KHR;
     stream->write(&opcode_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1126;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1126, 1);
-    stream->write((uint64_t*)&cgen_var_1126, 1 * 8);
+    uint64_t cgen_var_1136;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1136, 1);
+    stream->write((uint64_t*)&cgen_var_1136, 1 * 8);
     marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
     marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
     unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
@@ -16170,9 +16300,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1127;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1127, 1);
-        countingStream->write((uint64_t*)&cgen_var_1127, 1 * 8);
+        uint64_t cgen_var_1137;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1137, 1);
+        countingStream->write((uint64_t*)&cgen_var_1137, 1 * 8);
         marshal_VkBufferMemoryRequirementsInfo2(countingStream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
         marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
     }
@@ -16181,9 +16311,9 @@
     uint32_t opcode_vkGetBufferMemoryRequirements2KHR = OP_vkGetBufferMemoryRequirements2KHR;
     stream->write(&opcode_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1128;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1128, 1);
-    stream->write((uint64_t*)&cgen_var_1128, 1 * 8);
+    uint64_t cgen_var_1138;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1138, 1);
+    stream->write((uint64_t*)&cgen_var_1138, 1 * 8);
     marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
     marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
     unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
@@ -16221,20 +16351,20 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1129;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1129, 1);
-        countingStream->write((uint64_t*)&cgen_var_1129, 1 * 8);
+        uint64_t cgen_var_1139;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1139, 1);
+        countingStream->write((uint64_t*)&cgen_var_1139, 1 * 8);
         marshal_VkImageSparseMemoryRequirementsInfo2(countingStream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1130 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
-        countingStream->putBe64(cgen_var_1130);
+        uint64_t cgen_var_1140 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+        countingStream->putBe64(cgen_var_1140);
         if (pSparseMemoryRequirementCount)
         {
             countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_1131 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
-        countingStream->putBe64(cgen_var_1131);
+        uint64_t cgen_var_1141 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+        countingStream->putBe64(cgen_var_1141);
         if (pSparseMemoryRequirements)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -16248,20 +16378,20 @@
     uint32_t opcode_vkGetImageSparseMemoryRequirements2KHR = OP_vkGetImageSparseMemoryRequirements2KHR;
     stream->write(&opcode_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1132;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1132, 1);
-    stream->write((uint64_t*)&cgen_var_1132, 1 * 8);
+    uint64_t cgen_var_1142;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1142, 1);
+    stream->write((uint64_t*)&cgen_var_1142, 1 * 8);
     marshal_VkImageSparseMemoryRequirementsInfo2(stream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1133 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
-    stream->putBe64(cgen_var_1133);
+    uint64_t cgen_var_1143 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+    stream->putBe64(cgen_var_1143);
     if (pSparseMemoryRequirementCount)
     {
         stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_1134 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
-    stream->putBe64(cgen_var_1134);
+    uint64_t cgen_var_1144 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+    stream->putBe64(cgen_var_1144);
     if (pSparseMemoryRequirements)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -16347,45 +16477,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1137;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1137, 1);
-        countingStream->write((uint64_t*)&cgen_var_1137, 1 * 8);
+        uint64_t cgen_var_1147;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1147, 1);
+        countingStream->write((uint64_t*)&cgen_var_1147, 1 * 8);
         marshal_VkSamplerYcbcrConversionCreateInfo(countingStream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1138 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1138);
+        uint64_t cgen_var_1148 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1148);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1139;
-        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1139, 1);
-        countingStream->write((uint64_t*)&cgen_var_1139, 8);
+        uint64_t cgen_var_1149;
+        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1149, 1);
+        countingStream->write((uint64_t*)&cgen_var_1149, 8);
     }
     uint32_t packetSize_vkCreateSamplerYcbcrConversionKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateSamplerYcbcrConversionKHR = OP_vkCreateSamplerYcbcrConversionKHR;
     stream->write(&opcode_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1140;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1140, 1);
-    stream->write((uint64_t*)&cgen_var_1140, 1 * 8);
+    uint64_t cgen_var_1150;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1150, 1);
+    stream->write((uint64_t*)&cgen_var_1150, 1 * 8);
     marshal_VkSamplerYcbcrConversionCreateInfo(stream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1141 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1141);
+    uint64_t cgen_var_1151 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1151);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1142;
-    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1142, 1);
-    stream->write((uint64_t*)&cgen_var_1142, 8);
+    uint64_t cgen_var_1152;
+    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1152, 1);
+    stream->write((uint64_t*)&cgen_var_1152, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_1143;
-    stream->read((uint64_t*)&cgen_var_1143, 8);
-    stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_1143, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
+    uint64_t cgen_var_1153;
+    stream->read((uint64_t*)&cgen_var_1153, 8);
+    stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_1153, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
     VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSamplerYcbcrConversionKHR_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -16424,15 +16554,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1144;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1144, 1);
-        countingStream->write((uint64_t*)&cgen_var_1144, 1 * 8);
-        uint64_t cgen_var_1145;
-        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1145, 1);
-        countingStream->write((uint64_t*)&cgen_var_1145, 1 * 8);
+        uint64_t cgen_var_1154;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1154, 1);
+        countingStream->write((uint64_t*)&cgen_var_1154, 1 * 8);
+        uint64_t cgen_var_1155;
+        countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1155, 1);
+        countingStream->write((uint64_t*)&cgen_var_1155, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1146 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1146);
+        uint64_t cgen_var_1156 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1156);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -16443,15 +16573,15 @@
     uint32_t opcode_vkDestroySamplerYcbcrConversionKHR = OP_vkDestroySamplerYcbcrConversionKHR;
     stream->write(&opcode_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1147;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1147, 1);
-    stream->write((uint64_t*)&cgen_var_1147, 1 * 8);
-    uint64_t cgen_var_1148;
-    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1148, 1);
-    stream->write((uint64_t*)&cgen_var_1148, 1 * 8);
+    uint64_t cgen_var_1157;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1157, 1);
+    stream->write((uint64_t*)&cgen_var_1157, 1 * 8);
+    uint64_t cgen_var_1158;
+    stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1158, 1);
+    stream->write((uint64_t*)&cgen_var_1158, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1149 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1149);
+    uint64_t cgen_var_1159 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1159);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -16495,9 +16625,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1150;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1150, 1);
-        countingStream->write((uint64_t*)&cgen_var_1150, 1 * 8);
+        uint64_t cgen_var_1160;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1160, 1);
+        countingStream->write((uint64_t*)&cgen_var_1160, 1 * 8);
         countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
         {
@@ -16509,9 +16639,9 @@
     uint32_t opcode_vkBindBufferMemory2KHR = OP_vkBindBufferMemory2KHR;
     stream->write(&opcode_vkBindBufferMemory2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkBindBufferMemory2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1151;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1151, 1);
-    stream->write((uint64_t*)&cgen_var_1151, 1 * 8);
+    uint64_t cgen_var_1161;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1161, 1);
+    stream->write((uint64_t*)&cgen_var_1161, 1 * 8);
     stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
     {
@@ -16560,9 +16690,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1152;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1152, 1);
-        countingStream->write((uint64_t*)&cgen_var_1152, 1 * 8);
+        uint64_t cgen_var_1162;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1162, 1);
+        countingStream->write((uint64_t*)&cgen_var_1162, 1 * 8);
         countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
         {
@@ -16574,9 +16704,9 @@
     uint32_t opcode_vkBindImageMemory2KHR = OP_vkBindImageMemory2KHR;
     stream->write(&opcode_vkBindImageMemory2KHR, sizeof(uint32_t));
     stream->write(&packetSize_vkBindImageMemory2KHR, sizeof(uint32_t));
-    uint64_t cgen_var_1153;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1153, 1);
-    stream->write((uint64_t*)&cgen_var_1153, 1 * 8);
+    uint64_t cgen_var_1163;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1163, 1);
+    stream->write((uint64_t*)&cgen_var_1163, 1 * 8);
     stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
     {
@@ -16619,9 +16749,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1154;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1154, 1);
-        countingStream->write((uint64_t*)&cgen_var_1154, 1 * 8);
+        uint64_t cgen_var_1164;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1164, 1);
+        countingStream->write((uint64_t*)&cgen_var_1164, 1 * 8);
         marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
         marshal_VkDescriptorSetLayoutSupport(countingStream, (VkDescriptorSetLayoutSupport*)(pSupport));
     }
@@ -16630,9 +16760,9 @@
     uint32_t opcode_vkGetDescriptorSetLayoutSupportKHR = OP_vkGetDescriptorSetLayoutSupportKHR;
     stream->write(&opcode_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1155;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1155, 1);
-    stream->write((uint64_t*)&cgen_var_1155, 1 * 8);
+    uint64_t cgen_var_1165;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1165, 1);
+    stream->write((uint64_t*)&cgen_var_1165, 1 * 8);
     marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
     marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
     unmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
@@ -16676,16 +16806,16 @@
     local_stride = stride;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1156;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1156, 1);
-        countingStream->write((uint64_t*)&cgen_var_1156, 1 * 8);
-        uint64_t cgen_var_1157;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1157, 1);
-        countingStream->write((uint64_t*)&cgen_var_1157, 1 * 8);
+        uint64_t cgen_var_1166;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1166, 1);
+        countingStream->write((uint64_t*)&cgen_var_1166, 1 * 8);
+        uint64_t cgen_var_1167;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1167, 1);
+        countingStream->write((uint64_t*)&cgen_var_1167, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
-        uint64_t cgen_var_1158;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1158, 1);
-        countingStream->write((uint64_t*)&cgen_var_1158, 1 * 8);
+        uint64_t cgen_var_1168;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1168, 1);
+        countingStream->write((uint64_t*)&cgen_var_1168, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
         countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -16695,16 +16825,16 @@
     uint32_t opcode_vkCmdDrawIndirectCountKHR = OP_vkCmdDrawIndirectCountKHR;
     stream->write(&opcode_vkCmdDrawIndirectCountKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDrawIndirectCountKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1159;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1159, 1);
-    stream->write((uint64_t*)&cgen_var_1159, 1 * 8);
-    uint64_t cgen_var_1160;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1160, 1);
-    stream->write((uint64_t*)&cgen_var_1160, 1 * 8);
+    uint64_t cgen_var_1169;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1169, 1);
+    stream->write((uint64_t*)&cgen_var_1169, 1 * 8);
+    uint64_t cgen_var_1170;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1170, 1);
+    stream->write((uint64_t*)&cgen_var_1170, 1 * 8);
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
-    uint64_t cgen_var_1161;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1161, 1);
-    stream->write((uint64_t*)&cgen_var_1161, 1 * 8);
+    uint64_t cgen_var_1171;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1171, 1);
+    stream->write((uint64_t*)&cgen_var_1171, 1 * 8);
     stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -16742,16 +16872,16 @@
     local_stride = stride;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1162;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1162, 1);
-        countingStream->write((uint64_t*)&cgen_var_1162, 1 * 8);
-        uint64_t cgen_var_1163;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1163, 1);
-        countingStream->write((uint64_t*)&cgen_var_1163, 1 * 8);
+        uint64_t cgen_var_1172;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1172, 1);
+        countingStream->write((uint64_t*)&cgen_var_1172, 1 * 8);
+        uint64_t cgen_var_1173;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1173, 1);
+        countingStream->write((uint64_t*)&cgen_var_1173, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
-        uint64_t cgen_var_1164;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1164, 1);
-        countingStream->write((uint64_t*)&cgen_var_1164, 1 * 8);
+        uint64_t cgen_var_1174;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1174, 1);
+        countingStream->write((uint64_t*)&cgen_var_1174, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
         countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -16761,16 +16891,16 @@
     uint32_t opcode_vkCmdDrawIndexedIndirectCountKHR = OP_vkCmdDrawIndexedIndirectCountKHR;
     stream->write(&opcode_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t));
-    uint64_t cgen_var_1165;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1165, 1);
-    stream->write((uint64_t*)&cgen_var_1165, 1 * 8);
-    uint64_t cgen_var_1166;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1166, 1);
-    stream->write((uint64_t*)&cgen_var_1166, 1 * 8);
+    uint64_t cgen_var_1175;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1175, 1);
+    stream->write((uint64_t*)&cgen_var_1175, 1 * 8);
+    uint64_t cgen_var_1176;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1176, 1);
+    stream->write((uint64_t*)&cgen_var_1176, 1 * 8);
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
-    uint64_t cgen_var_1167;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1167, 1);
-    stream->write((uint64_t*)&cgen_var_1167, 1 * 8);
+    uint64_t cgen_var_1177;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1177, 1);
+    stream->write((uint64_t*)&cgen_var_1177, 1 * 8);
     stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -16801,9 +16931,9 @@
     local_imageUsage = imageUsage;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1168;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1168, 1);
-        countingStream->write((uint64_t*)&cgen_var_1168, 1 * 8);
+        uint64_t cgen_var_1178;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1178, 1);
+        countingStream->write((uint64_t*)&cgen_var_1178, 1 * 8);
         countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
         countingStream->write((VkImageUsageFlags*)&local_imageUsage, sizeof(VkImageUsageFlags));
         countingStream->write((int*)grallocUsage, sizeof(int));
@@ -16813,9 +16943,9 @@
     uint32_t opcode_vkGetSwapchainGrallocUsageANDROID = OP_vkGetSwapchainGrallocUsageANDROID;
     stream->write(&opcode_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
     stream->write(&packetSize_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
-    uint64_t cgen_var_1169;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1169, 1);
-    stream->write((uint64_t*)&cgen_var_1169, 1 * 8);
+    uint64_t cgen_var_1179;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1179, 1);
+    stream->write((uint64_t*)&cgen_var_1179, 1 * 8);
     stream->write((VkFormat*)&local_format, sizeof(VkFormat));
     stream->write((VkImageUsageFlags*)&local_imageUsage, sizeof(VkImageUsageFlags));
     stream->write((int*)grallocUsage, sizeof(int));
@@ -16855,38 +16985,38 @@
     mImpl->resources()->unwrap_vkAcquireImageANDROID_nativeFenceFd(nativeFenceFd, &local_nativeFenceFd);
     countingStream->rewind();
     {
-        uint64_t cgen_var_1170;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1170, 1);
-        countingStream->write((uint64_t*)&cgen_var_1170, 1 * 8);
-        uint64_t cgen_var_1171;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1171, 1);
-        countingStream->write((uint64_t*)&cgen_var_1171, 1 * 8);
+        uint64_t cgen_var_1180;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1180, 1);
+        countingStream->write((uint64_t*)&cgen_var_1180, 1 * 8);
+        uint64_t cgen_var_1181;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1181, 1);
+        countingStream->write((uint64_t*)&cgen_var_1181, 1 * 8);
         countingStream->write((int*)&local_nativeFenceFd, sizeof(int));
-        uint64_t cgen_var_1172;
-        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1172, 1);
-        countingStream->write((uint64_t*)&cgen_var_1172, 1 * 8);
-        uint64_t cgen_var_1173;
-        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1173, 1);
-        countingStream->write((uint64_t*)&cgen_var_1173, 1 * 8);
+        uint64_t cgen_var_1182;
+        countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1182, 1);
+        countingStream->write((uint64_t*)&cgen_var_1182, 1 * 8);
+        uint64_t cgen_var_1183;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1183, 1);
+        countingStream->write((uint64_t*)&cgen_var_1183, 1 * 8);
     }
     uint32_t packetSize_vkAcquireImageANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkAcquireImageANDROID = OP_vkAcquireImageANDROID;
     stream->write(&opcode_vkAcquireImageANDROID, sizeof(uint32_t));
     stream->write(&packetSize_vkAcquireImageANDROID, sizeof(uint32_t));
-    uint64_t cgen_var_1174;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1174, 1);
-    stream->write((uint64_t*)&cgen_var_1174, 1 * 8);
-    uint64_t cgen_var_1175;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1175, 1);
-    stream->write((uint64_t*)&cgen_var_1175, 1 * 8);
+    uint64_t cgen_var_1184;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1184, 1);
+    stream->write((uint64_t*)&cgen_var_1184, 1 * 8);
+    uint64_t cgen_var_1185;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1185, 1);
+    stream->write((uint64_t*)&cgen_var_1185, 1 * 8);
     stream->write((int*)&local_nativeFenceFd, sizeof(int));
-    uint64_t cgen_var_1176;
-    stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1176, 1);
-    stream->write((uint64_t*)&cgen_var_1176, 1 * 8);
-    uint64_t cgen_var_1177;
-    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1177, 1);
-    stream->write((uint64_t*)&cgen_var_1177, 1 * 8);
+    uint64_t cgen_var_1186;
+    stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1186, 1);
+    stream->write((uint64_t*)&cgen_var_1186, 1 * 8);
+    uint64_t cgen_var_1187;
+    stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1187, 1);
+    stream->write((uint64_t*)&cgen_var_1187, 1 * 8);
     VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkAcquireImageANDROID_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -16923,26 +17053,26 @@
     local_image = image;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1178;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1178, 1);
-        countingStream->write((uint64_t*)&cgen_var_1178, 1 * 8);
+        uint64_t cgen_var_1188;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1188, 1);
+        countingStream->write((uint64_t*)&cgen_var_1188, 1 * 8);
         countingStream->write((uint32_t*)&local_waitSemaphoreCount, sizeof(uint32_t));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1179 = (uint64_t)(uintptr_t)local_pWaitSemaphores;
-        countingStream->putBe64(cgen_var_1179);
+        uint64_t cgen_var_1189 = (uint64_t)(uintptr_t)local_pWaitSemaphores;
+        countingStream->putBe64(cgen_var_1189);
         if (local_pWaitSemaphores)
         {
             if (((waitSemaphoreCount)))
             {
-                uint64_t* cgen_var_1180;
-                countingStream->alloc((void**)&cgen_var_1180, ((waitSemaphoreCount)) * 8);
-                countingStream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, cgen_var_1180, ((waitSemaphoreCount)));
-                countingStream->write((uint64_t*)cgen_var_1180, ((waitSemaphoreCount)) * 8);
+                uint64_t* cgen_var_1190;
+                countingStream->alloc((void**)&cgen_var_1190, ((waitSemaphoreCount)) * 8);
+                countingStream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, cgen_var_1190, ((waitSemaphoreCount)));
+                countingStream->write((uint64_t*)cgen_var_1190, ((waitSemaphoreCount)) * 8);
             }
         }
-        uint64_t cgen_var_1181;
-        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1181, 1);
-        countingStream->write((uint64_t*)&cgen_var_1181, 1 * 8);
+        uint64_t cgen_var_1191;
+        countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1191, 1);
+        countingStream->write((uint64_t*)&cgen_var_1191, 1 * 8);
         countingStream->write((int*)pNativeFenceFd, sizeof(int));
     }
     uint32_t packetSize_vkQueueSignalReleaseImageANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -16950,26 +17080,26 @@
     uint32_t opcode_vkQueueSignalReleaseImageANDROID = OP_vkQueueSignalReleaseImageANDROID;
     stream->write(&opcode_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
     stream->write(&packetSize_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
-    uint64_t cgen_var_1182;
-    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1182, 1);
-    stream->write((uint64_t*)&cgen_var_1182, 1 * 8);
+    uint64_t cgen_var_1192;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1192, 1);
+    stream->write((uint64_t*)&cgen_var_1192, 1 * 8);
     stream->write((uint32_t*)&local_waitSemaphoreCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1183 = (uint64_t)(uintptr_t)local_pWaitSemaphores;
-    stream->putBe64(cgen_var_1183);
+    uint64_t cgen_var_1193 = (uint64_t)(uintptr_t)local_pWaitSemaphores;
+    stream->putBe64(cgen_var_1193);
     if (local_pWaitSemaphores)
     {
         if (((waitSemaphoreCount)))
         {
-            uint64_t* cgen_var_1184;
-            stream->alloc((void**)&cgen_var_1184, ((waitSemaphoreCount)) * 8);
-            stream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, cgen_var_1184, ((waitSemaphoreCount)));
-            stream->write((uint64_t*)cgen_var_1184, ((waitSemaphoreCount)) * 8);
+            uint64_t* cgen_var_1194;
+            stream->alloc((void**)&cgen_var_1194, ((waitSemaphoreCount)) * 8);
+            stream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, cgen_var_1194, ((waitSemaphoreCount)));
+            stream->write((uint64_t*)cgen_var_1194, ((waitSemaphoreCount)) * 8);
         }
     }
-    uint64_t cgen_var_1185;
-    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1185, 1);
-    stream->write((uint64_t*)&cgen_var_1185, 1 * 8);
+    uint64_t cgen_var_1195;
+    stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1195, 1);
+    stream->write((uint64_t*)&cgen_var_1195, 1 * 8);
     stream->write((int*)pNativeFenceFd, sizeof(int));
     stream->read((int*)pNativeFenceFd, sizeof(int));
     VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
@@ -17022,46 +17152,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1186;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1186, 1);
-        countingStream->write((uint64_t*)&cgen_var_1186, 1 * 8);
+        uint64_t cgen_var_1196;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1196, 1);
+        countingStream->write((uint64_t*)&cgen_var_1196, 1 * 8);
         marshal_VkDebugReportCallbackCreateInfoEXT(countingStream, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1187 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1187);
+        uint64_t cgen_var_1197 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1197);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1188;
-        countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1188, 1);
-        countingStream->write((uint64_t*)&cgen_var_1188, 8);
+        uint64_t cgen_var_1198;
+        countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1198, 1);
+        countingStream->write((uint64_t*)&cgen_var_1198, 8);
     }
     uint32_t packetSize_vkCreateDebugReportCallbackEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateDebugReportCallbackEXT = OP_vkCreateDebugReportCallbackEXT;
     stream->write(&opcode_vkCreateDebugReportCallbackEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateDebugReportCallbackEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1189;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1189, 1);
-    stream->write((uint64_t*)&cgen_var_1189, 1 * 8);
+    uint64_t cgen_var_1199;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1199, 1);
+    stream->write((uint64_t*)&cgen_var_1199, 1 * 8);
     marshal_VkDebugReportCallbackCreateInfoEXT(stream, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1190 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1190);
+    uint64_t cgen_var_1200 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1200);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1191;
-    stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1191, 1);
-    stream->write((uint64_t*)&cgen_var_1191, 8);
+    uint64_t cgen_var_1201;
+    stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1201, 1);
+    stream->write((uint64_t*)&cgen_var_1201, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_1192;
-    stream->read((uint64_t*)&cgen_var_1192, 8);
-    stream->handleMapping()->mapHandles_u64_VkDebugReportCallbackEXT(&cgen_var_1192, (VkDebugReportCallbackEXT*)pCallback, 1);
+    uint64_t cgen_var_1202;
+    stream->read((uint64_t*)&cgen_var_1202, 8);
+    stream->handleMapping()->mapHandles_u64_VkDebugReportCallbackEXT(&cgen_var_1202, (VkDebugReportCallbackEXT*)pCallback, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDebugReportCallbackEXT_VkResult_return, sizeof(VkResult));
@@ -17101,15 +17231,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1193;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1193, 1);
-        countingStream->write((uint64_t*)&cgen_var_1193, 1 * 8);
-        uint64_t cgen_var_1194;
-        countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1194, 1);
-        countingStream->write((uint64_t*)&cgen_var_1194, 1 * 8);
+        uint64_t cgen_var_1203;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1203, 1);
+        countingStream->write((uint64_t*)&cgen_var_1203, 1 * 8);
+        uint64_t cgen_var_1204;
+        countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1204, 1);
+        countingStream->write((uint64_t*)&cgen_var_1204, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1195 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1195);
+        uint64_t cgen_var_1205 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1205);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -17120,15 +17250,15 @@
     uint32_t opcode_vkDestroyDebugReportCallbackEXT = OP_vkDestroyDebugReportCallbackEXT;
     stream->write(&opcode_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1196;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1196, 1);
-    stream->write((uint64_t*)&cgen_var_1196, 1 * 8);
-    uint64_t cgen_var_1197;
-    stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1197, 1);
-    stream->write((uint64_t*)&cgen_var_1197, 1 * 8);
+    uint64_t cgen_var_1206;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1206, 1);
+    stream->write((uint64_t*)&cgen_var_1206, 1 * 8);
+    uint64_t cgen_var_1207;
+    stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1207, 1);
+    stream->write((uint64_t*)&cgen_var_1207, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1198 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1198);
+    uint64_t cgen_var_1208 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1208);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -17179,14 +17309,14 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1199;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1199, 1);
-        countingStream->write((uint64_t*)&cgen_var_1199, 1 * 8);
+        uint64_t cgen_var_1209;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1209, 1);
+        countingStream->write((uint64_t*)&cgen_var_1209, 1 * 8);
         countingStream->write((VkDebugReportFlagsEXT*)&local_flags, sizeof(VkDebugReportFlagsEXT));
         countingStream->write((VkDebugReportObjectTypeEXT*)&local_objectType, sizeof(VkDebugReportObjectTypeEXT));
         countingStream->write((uint64_t*)&local_object, sizeof(uint64_t));
-        uint64_t cgen_var_1200 = (uint64_t)local_location;
-        countingStream->putBe64(cgen_var_1200);
+        uint64_t cgen_var_1210 = (uint64_t)local_location;
+        countingStream->putBe64(cgen_var_1210);
         countingStream->write((int32_t*)&local_messageCode, sizeof(int32_t));
         countingStream->putString(local_pLayerPrefix);
         countingStream->putString(local_pMessage);
@@ -17196,14 +17326,14 @@
     uint32_t opcode_vkDebugReportMessageEXT = OP_vkDebugReportMessageEXT;
     stream->write(&opcode_vkDebugReportMessageEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkDebugReportMessageEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1201;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1201, 1);
-    stream->write((uint64_t*)&cgen_var_1201, 1 * 8);
+    uint64_t cgen_var_1211;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1211, 1);
+    stream->write((uint64_t*)&cgen_var_1211, 1 * 8);
     stream->write((VkDebugReportFlagsEXT*)&local_flags, sizeof(VkDebugReportFlagsEXT));
     stream->write((VkDebugReportObjectTypeEXT*)&local_objectType, sizeof(VkDebugReportObjectTypeEXT));
     stream->write((uint64_t*)&local_object, sizeof(uint64_t));
-    uint64_t cgen_var_1202 = (uint64_t)local_location;
-    stream->putBe64(cgen_var_1202);
+    uint64_t cgen_var_1212 = (uint64_t)local_location;
+    stream->putBe64(cgen_var_1212);
     stream->write((int32_t*)&local_messageCode, sizeof(int32_t));
     stream->putString(local_pLayerPrefix);
     stream->putString(local_pMessage);
@@ -17249,9 +17379,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1203;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1203, 1);
-        countingStream->write((uint64_t*)&cgen_var_1203, 1 * 8);
+        uint64_t cgen_var_1213;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1213, 1);
+        countingStream->write((uint64_t*)&cgen_var_1213, 1 * 8);
         marshal_VkDebugMarkerObjectTagInfoEXT(countingStream, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
     }
     uint32_t packetSize_vkDebugMarkerSetObjectTagEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -17259,9 +17389,9 @@
     uint32_t opcode_vkDebugMarkerSetObjectTagEXT = OP_vkDebugMarkerSetObjectTagEXT;
     stream->write(&opcode_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1204;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1204, 1);
-    stream->write((uint64_t*)&cgen_var_1204, 1 * 8);
+    uint64_t cgen_var_1214;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1214, 1);
+    stream->write((uint64_t*)&cgen_var_1214, 1 * 8);
     marshal_VkDebugMarkerObjectTagInfoEXT(stream, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
     VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
     stream->read(&vkDebugMarkerSetObjectTagEXT_VkResult_return, sizeof(VkResult));
@@ -17297,9 +17427,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1205;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1205, 1);
-        countingStream->write((uint64_t*)&cgen_var_1205, 1 * 8);
+        uint64_t cgen_var_1215;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1215, 1);
+        countingStream->write((uint64_t*)&cgen_var_1215, 1 * 8);
         marshal_VkDebugMarkerObjectNameInfoEXT(countingStream, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
     }
     uint32_t packetSize_vkDebugMarkerSetObjectNameEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -17307,9 +17437,9 @@
     uint32_t opcode_vkDebugMarkerSetObjectNameEXT = OP_vkDebugMarkerSetObjectNameEXT;
     stream->write(&opcode_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1206;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1206, 1);
-    stream->write((uint64_t*)&cgen_var_1206, 1 * 8);
+    uint64_t cgen_var_1216;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1216, 1);
+    stream->write((uint64_t*)&cgen_var_1216, 1 * 8);
     marshal_VkDebugMarkerObjectNameInfoEXT(stream, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
     VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
     stream->read(&vkDebugMarkerSetObjectNameEXT_VkResult_return, sizeof(VkResult));
@@ -17345,9 +17475,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1207;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1207, 1);
-        countingStream->write((uint64_t*)&cgen_var_1207, 1 * 8);
+        uint64_t cgen_var_1217;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1217, 1);
+        countingStream->write((uint64_t*)&cgen_var_1217, 1 * 8);
         marshal_VkDebugMarkerMarkerInfoEXT(countingStream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
     }
     uint32_t packetSize_vkCmdDebugMarkerBeginEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -17355,9 +17485,9 @@
     uint32_t opcode_vkCmdDebugMarkerBeginEXT = OP_vkCmdDebugMarkerBeginEXT;
     stream->write(&opcode_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1208;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1208, 1);
-    stream->write((uint64_t*)&cgen_var_1208, 1 * 8);
+    uint64_t cgen_var_1218;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1218, 1);
+    stream->write((uint64_t*)&cgen_var_1218, 1 * 8);
     marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
     mImpl->log("finish vkCmdDebugMarkerBeginEXT");;
 }
@@ -17375,18 +17505,18 @@
     local_commandBuffer = commandBuffer;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1209;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1209, 1);
-        countingStream->write((uint64_t*)&cgen_var_1209, 1 * 8);
+        uint64_t cgen_var_1219;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1219, 1);
+        countingStream->write((uint64_t*)&cgen_var_1219, 1 * 8);
     }
     uint32_t packetSize_vkCmdDebugMarkerEndEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCmdDebugMarkerEndEXT = OP_vkCmdDebugMarkerEndEXT;
     stream->write(&opcode_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1210;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1210, 1);
-    stream->write((uint64_t*)&cgen_var_1210, 1 * 8);
+    uint64_t cgen_var_1220;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1220, 1);
+    stream->write((uint64_t*)&cgen_var_1220, 1 * 8);
     mImpl->log("finish vkCmdDebugMarkerEndEXT");;
 }
 
@@ -17415,9 +17545,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1211;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1211, 1);
-        countingStream->write((uint64_t*)&cgen_var_1211, 1 * 8);
+        uint64_t cgen_var_1221;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1221, 1);
+        countingStream->write((uint64_t*)&cgen_var_1221, 1 * 8);
         marshal_VkDebugMarkerMarkerInfoEXT(countingStream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
     }
     uint32_t packetSize_vkCmdDebugMarkerInsertEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -17425,9 +17555,9 @@
     uint32_t opcode_vkCmdDebugMarkerInsertEXT = OP_vkCmdDebugMarkerInsertEXT;
     stream->write(&opcode_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1212;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1212, 1);
-    stream->write((uint64_t*)&cgen_var_1212, 1 * 8);
+    uint64_t cgen_var_1222;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1222, 1);
+    stream->write((uint64_t*)&cgen_var_1222, 1 * 8);
     marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
     mImpl->log("finish vkCmdDebugMarkerInsertEXT");;
 }
@@ -17469,16 +17599,16 @@
     local_stride = stride;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1213;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1213, 1);
-        countingStream->write((uint64_t*)&cgen_var_1213, 1 * 8);
-        uint64_t cgen_var_1214;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1214, 1);
-        countingStream->write((uint64_t*)&cgen_var_1214, 1 * 8);
+        uint64_t cgen_var_1223;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1223, 1);
+        countingStream->write((uint64_t*)&cgen_var_1223, 1 * 8);
+        uint64_t cgen_var_1224;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1224, 1);
+        countingStream->write((uint64_t*)&cgen_var_1224, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
-        uint64_t cgen_var_1215;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1215, 1);
-        countingStream->write((uint64_t*)&cgen_var_1215, 1 * 8);
+        uint64_t cgen_var_1225;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1225, 1);
+        countingStream->write((uint64_t*)&cgen_var_1225, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
         countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -17488,16 +17618,16 @@
     uint32_t opcode_vkCmdDrawIndirectCountAMD = OP_vkCmdDrawIndirectCountAMD;
     stream->write(&opcode_vkCmdDrawIndirectCountAMD, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDrawIndirectCountAMD, sizeof(uint32_t));
-    uint64_t cgen_var_1216;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1216, 1);
-    stream->write((uint64_t*)&cgen_var_1216, 1 * 8);
-    uint64_t cgen_var_1217;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1217, 1);
-    stream->write((uint64_t*)&cgen_var_1217, 1 * 8);
+    uint64_t cgen_var_1226;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1226, 1);
+    stream->write((uint64_t*)&cgen_var_1226, 1 * 8);
+    uint64_t cgen_var_1227;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1227, 1);
+    stream->write((uint64_t*)&cgen_var_1227, 1 * 8);
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
-    uint64_t cgen_var_1218;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1218, 1);
-    stream->write((uint64_t*)&cgen_var_1218, 1 * 8);
+    uint64_t cgen_var_1228;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1228, 1);
+    stream->write((uint64_t*)&cgen_var_1228, 1 * 8);
     stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -17535,16 +17665,16 @@
     local_stride = stride;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1219;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1219, 1);
-        countingStream->write((uint64_t*)&cgen_var_1219, 1 * 8);
-        uint64_t cgen_var_1220;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1220, 1);
-        countingStream->write((uint64_t*)&cgen_var_1220, 1 * 8);
+        uint64_t cgen_var_1229;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1229, 1);
+        countingStream->write((uint64_t*)&cgen_var_1229, 1 * 8);
+        uint64_t cgen_var_1230;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1230, 1);
+        countingStream->write((uint64_t*)&cgen_var_1230, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
-        uint64_t cgen_var_1221;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1221, 1);
-        countingStream->write((uint64_t*)&cgen_var_1221, 1 * 8);
+        uint64_t cgen_var_1231;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1231, 1);
+        countingStream->write((uint64_t*)&cgen_var_1231, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
         countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -17554,16 +17684,16 @@
     uint32_t opcode_vkCmdDrawIndexedIndirectCountAMD = OP_vkCmdDrawIndexedIndirectCountAMD;
     stream->write(&opcode_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t));
-    uint64_t cgen_var_1222;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1222, 1);
-    stream->write((uint64_t*)&cgen_var_1222, 1 * 8);
-    uint64_t cgen_var_1223;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1223, 1);
-    stream->write((uint64_t*)&cgen_var_1223, 1 * 8);
+    uint64_t cgen_var_1232;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1232, 1);
+    stream->write((uint64_t*)&cgen_var_1232, 1 * 8);
+    uint64_t cgen_var_1233;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1233, 1);
+    stream->write((uint64_t*)&cgen_var_1233, 1 * 8);
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
-    uint64_t cgen_var_1224;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1224, 1);
-    stream->write((uint64_t*)&cgen_var_1224, 1 * 8);
+    uint64_t cgen_var_1234;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1234, 1);
+    stream->write((uint64_t*)&cgen_var_1234, 1 * 8);
     stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -17604,25 +17734,25 @@
     local_infoType = infoType;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1225;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1225, 1);
-        countingStream->write((uint64_t*)&cgen_var_1225, 1 * 8);
-        uint64_t cgen_var_1226;
-        countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1226, 1);
-        countingStream->write((uint64_t*)&cgen_var_1226, 1 * 8);
+        uint64_t cgen_var_1235;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1235, 1);
+        countingStream->write((uint64_t*)&cgen_var_1235, 1 * 8);
+        uint64_t cgen_var_1236;
+        countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1236, 1);
+        countingStream->write((uint64_t*)&cgen_var_1236, 1 * 8);
         countingStream->write((VkShaderStageFlagBits*)&local_shaderStage, sizeof(VkShaderStageFlagBits));
         countingStream->write((VkShaderInfoTypeAMD*)&local_infoType, sizeof(VkShaderInfoTypeAMD));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1227 = (uint64_t)(uintptr_t)pInfoSize;
-        countingStream->putBe64(cgen_var_1227);
+        uint64_t cgen_var_1237 = (uint64_t)(uintptr_t)pInfoSize;
+        countingStream->putBe64(cgen_var_1237);
         if (pInfoSize)
         {
-            uint64_t cgen_var_1228 = (uint64_t)(*pInfoSize);
-            countingStream->putBe64(cgen_var_1228);
+            uint64_t cgen_var_1238 = (uint64_t)(*pInfoSize);
+            countingStream->putBe64(cgen_var_1238);
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_1229 = (uint64_t)(uintptr_t)pInfo;
-        countingStream->putBe64(cgen_var_1229);
+        uint64_t cgen_var_1239 = (uint64_t)(uintptr_t)pInfo;
+        countingStream->putBe64(cgen_var_1239);
         if (pInfo)
         {
             countingStream->write((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
@@ -17633,25 +17763,25 @@
     uint32_t opcode_vkGetShaderInfoAMD = OP_vkGetShaderInfoAMD;
     stream->write(&opcode_vkGetShaderInfoAMD, sizeof(uint32_t));
     stream->write(&packetSize_vkGetShaderInfoAMD, sizeof(uint32_t));
-    uint64_t cgen_var_1230;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1230, 1);
-    stream->write((uint64_t*)&cgen_var_1230, 1 * 8);
-    uint64_t cgen_var_1231;
-    stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1231, 1);
-    stream->write((uint64_t*)&cgen_var_1231, 1 * 8);
+    uint64_t cgen_var_1240;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1240, 1);
+    stream->write((uint64_t*)&cgen_var_1240, 1 * 8);
+    uint64_t cgen_var_1241;
+    stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1241, 1);
+    stream->write((uint64_t*)&cgen_var_1241, 1 * 8);
     stream->write((VkShaderStageFlagBits*)&local_shaderStage, sizeof(VkShaderStageFlagBits));
     stream->write((VkShaderInfoTypeAMD*)&local_infoType, sizeof(VkShaderInfoTypeAMD));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1232 = (uint64_t)(uintptr_t)pInfoSize;
-    stream->putBe64(cgen_var_1232);
+    uint64_t cgen_var_1242 = (uint64_t)(uintptr_t)pInfoSize;
+    stream->putBe64(cgen_var_1242);
     if (pInfoSize)
     {
-        uint64_t cgen_var_1233 = (uint64_t)(*pInfoSize);
-        stream->putBe64(cgen_var_1233);
+        uint64_t cgen_var_1243 = (uint64_t)(*pInfoSize);
+        stream->putBe64(cgen_var_1243);
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_1234 = (uint64_t)(uintptr_t)pInfo;
-    stream->putBe64(cgen_var_1234);
+    uint64_t cgen_var_1244 = (uint64_t)(uintptr_t)pInfo;
+    stream->putBe64(cgen_var_1244);
     if (pInfo)
     {
         stream->write((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
@@ -17725,9 +17855,9 @@
     local_externalHandleType = externalHandleType;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1238;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1238, 1);
-        countingStream->write((uint64_t*)&cgen_var_1238, 1 * 8);
+        uint64_t cgen_var_1248;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1248, 1);
+        countingStream->write((uint64_t*)&cgen_var_1248, 1 * 8);
         countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
         countingStream->write((VkImageType*)&local_type, sizeof(VkImageType));
         countingStream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
@@ -17741,9 +17871,9 @@
     uint32_t opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
     stream->write(&opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t));
-    uint64_t cgen_var_1239;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1239, 1);
-    stream->write((uint64_t*)&cgen_var_1239, 1 * 8);
+    uint64_t cgen_var_1249;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1249, 1);
+    stream->write((uint64_t*)&cgen_var_1249, 1 * 8);
     stream->write((VkFormat*)&local_format, sizeof(VkFormat));
     stream->write((VkImageType*)&local_type, sizeof(VkImageType));
     stream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
@@ -17790,12 +17920,12 @@
     mImpl->resources()->deviceMemoryTransform_tohost(&local_memory, 1, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0);
     countingStream->rewind();
     {
-        uint64_t cgen_var_1240;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1240, 1);
-        countingStream->write((uint64_t*)&cgen_var_1240, 1 * 8);
-        uint64_t cgen_var_1241;
-        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1241, 1);
-        countingStream->write((uint64_t*)&cgen_var_1241, 1 * 8);
+        uint64_t cgen_var_1250;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1250, 1);
+        countingStream->write((uint64_t*)&cgen_var_1250, 1 * 8);
+        uint64_t cgen_var_1251;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1251, 1);
+        countingStream->write((uint64_t*)&cgen_var_1251, 1 * 8);
         countingStream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
         countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
     }
@@ -17804,12 +17934,12 @@
     uint32_t opcode_vkGetMemoryWin32HandleNV = OP_vkGetMemoryWin32HandleNV;
     stream->write(&opcode_vkGetMemoryWin32HandleNV, sizeof(uint32_t));
     stream->write(&packetSize_vkGetMemoryWin32HandleNV, sizeof(uint32_t));
-    uint64_t cgen_var_1242;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1242, 1);
-    stream->write((uint64_t*)&cgen_var_1242, 1 * 8);
-    uint64_t cgen_var_1243;
-    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1243, 1);
-    stream->write((uint64_t*)&cgen_var_1243, 1 * 8);
+    uint64_t cgen_var_1252;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1252, 1);
+    stream->write((uint64_t*)&cgen_var_1252, 1 * 8);
+    uint64_t cgen_var_1253;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1253, 1);
+    stream->write((uint64_t*)&cgen_var_1253, 1 * 8);
     stream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
     stream->write((HANDLE*)pHandle, sizeof(HANDLE));
     stream->read((HANDLE*)pHandle, sizeof(HANDLE));
@@ -17867,45 +17997,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1244;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1244, 1);
-        countingStream->write((uint64_t*)&cgen_var_1244, 1 * 8);
+        uint64_t cgen_var_1254;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1254, 1);
+        countingStream->write((uint64_t*)&cgen_var_1254, 1 * 8);
         marshal_VkViSurfaceCreateInfoNN(countingStream, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1245 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1245);
+        uint64_t cgen_var_1255 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1255);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1246;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1246, 1);
-        countingStream->write((uint64_t*)&cgen_var_1246, 8);
+        uint64_t cgen_var_1256;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1256, 1);
+        countingStream->write((uint64_t*)&cgen_var_1256, 8);
     }
     uint32_t packetSize_vkCreateViSurfaceNN = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateViSurfaceNN = OP_vkCreateViSurfaceNN;
     stream->write(&opcode_vkCreateViSurfaceNN, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateViSurfaceNN, sizeof(uint32_t));
-    uint64_t cgen_var_1247;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1247, 1);
-    stream->write((uint64_t*)&cgen_var_1247, 1 * 8);
+    uint64_t cgen_var_1257;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1257, 1);
+    stream->write((uint64_t*)&cgen_var_1257, 1 * 8);
     marshal_VkViSurfaceCreateInfoNN(stream, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1248 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1248);
+    uint64_t cgen_var_1258 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1258);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1249;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1249, 1);
-    stream->write((uint64_t*)&cgen_var_1249, 8);
+    uint64_t cgen_var_1259;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1259, 1);
+    stream->write((uint64_t*)&cgen_var_1259, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_1250;
-    stream->read((uint64_t*)&cgen_var_1250, 8);
-    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1250, (VkSurfaceKHR*)pSurface, 1);
+    uint64_t cgen_var_1260;
+    stream->read((uint64_t*)&cgen_var_1260, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1260, (VkSurfaceKHR*)pSurface, 1);
     VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
     stream->read(&vkCreateViSurfaceNN_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -17946,9 +18076,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1251;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1251, 1);
-        countingStream->write((uint64_t*)&cgen_var_1251, 1 * 8);
+        uint64_t cgen_var_1261;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1261, 1);
+        countingStream->write((uint64_t*)&cgen_var_1261, 1 * 8);
         marshal_VkConditionalRenderingBeginInfoEXT(countingStream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
     }
     uint32_t packetSize_vkCmdBeginConditionalRenderingEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -17956,9 +18086,9 @@
     uint32_t opcode_vkCmdBeginConditionalRenderingEXT = OP_vkCmdBeginConditionalRenderingEXT;
     stream->write(&opcode_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1252;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1252, 1);
-    stream->write((uint64_t*)&cgen_var_1252, 1 * 8);
+    uint64_t cgen_var_1262;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1262, 1);
+    stream->write((uint64_t*)&cgen_var_1262, 1 * 8);
     marshal_VkConditionalRenderingBeginInfoEXT(stream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
     mImpl->log("finish vkCmdBeginConditionalRenderingEXT");;
 }
@@ -17976,18 +18106,18 @@
     local_commandBuffer = commandBuffer;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1253;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1253, 1);
-        countingStream->write((uint64_t*)&cgen_var_1253, 1 * 8);
+        uint64_t cgen_var_1263;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1263, 1);
+        countingStream->write((uint64_t*)&cgen_var_1263, 1 * 8);
     }
     uint32_t packetSize_vkCmdEndConditionalRenderingEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCmdEndConditionalRenderingEXT = OP_vkCmdEndConditionalRenderingEXT;
     stream->write(&opcode_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1254;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1254, 1);
-    stream->write((uint64_t*)&cgen_var_1254, 1 * 8);
+    uint64_t cgen_var_1264;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1264, 1);
+    stream->write((uint64_t*)&cgen_var_1264, 1 * 8);
     mImpl->log("finish vkCmdEndConditionalRenderingEXT");;
 }
 
@@ -18018,9 +18148,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1255;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1255, 1);
-        countingStream->write((uint64_t*)&cgen_var_1255, 1 * 8);
+        uint64_t cgen_var_1265;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1265, 1);
+        countingStream->write((uint64_t*)&cgen_var_1265, 1 * 8);
         marshal_VkCmdProcessCommandsInfoNVX(countingStream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
     }
     uint32_t packetSize_vkCmdProcessCommandsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -18028,9 +18158,9 @@
     uint32_t opcode_vkCmdProcessCommandsNVX = OP_vkCmdProcessCommandsNVX;
     stream->write(&opcode_vkCmdProcessCommandsNVX, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdProcessCommandsNVX, sizeof(uint32_t));
-    uint64_t cgen_var_1256;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1256, 1);
-    stream->write((uint64_t*)&cgen_var_1256, 1 * 8);
+    uint64_t cgen_var_1266;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1266, 1);
+    stream->write((uint64_t*)&cgen_var_1266, 1 * 8);
     marshal_VkCmdProcessCommandsInfoNVX(stream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
     mImpl->log("finish vkCmdProcessCommandsNVX");;
 }
@@ -18060,9 +18190,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1257;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1257, 1);
-        countingStream->write((uint64_t*)&cgen_var_1257, 1 * 8);
+        uint64_t cgen_var_1267;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1267, 1);
+        countingStream->write((uint64_t*)&cgen_var_1267, 1 * 8);
         marshal_VkCmdReserveSpaceForCommandsInfoNVX(countingStream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
     }
     uint32_t packetSize_vkCmdReserveSpaceForCommandsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -18070,9 +18200,9 @@
     uint32_t opcode_vkCmdReserveSpaceForCommandsNVX = OP_vkCmdReserveSpaceForCommandsNVX;
     stream->write(&opcode_vkCmdReserveSpaceForCommandsNVX, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdReserveSpaceForCommandsNVX, sizeof(uint32_t));
-    uint64_t cgen_var_1258;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1258, 1);
-    stream->write((uint64_t*)&cgen_var_1258, 1 * 8);
+    uint64_t cgen_var_1268;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1268, 1);
+    stream->write((uint64_t*)&cgen_var_1268, 1 * 8);
     marshal_VkCmdReserveSpaceForCommandsInfoNVX(stream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
     mImpl->log("finish vkCmdReserveSpaceForCommandsNVX");;
 }
@@ -18116,46 +18246,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1259;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1259, 1);
-        countingStream->write((uint64_t*)&cgen_var_1259, 1 * 8);
+        uint64_t cgen_var_1269;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1269, 1);
+        countingStream->write((uint64_t*)&cgen_var_1269, 1 * 8);
         marshal_VkIndirectCommandsLayoutCreateInfoNVX(countingStream, (VkIndirectCommandsLayoutCreateInfoNVX*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1260 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1260);
+        uint64_t cgen_var_1270 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1270);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1261;
-        countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1261, 1);
-        countingStream->write((uint64_t*)&cgen_var_1261, 8);
+        uint64_t cgen_var_1271;
+        countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1271, 1);
+        countingStream->write((uint64_t*)&cgen_var_1271, 8);
     }
     uint32_t packetSize_vkCreateIndirectCommandsLayoutNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateIndirectCommandsLayoutNVX = OP_vkCreateIndirectCommandsLayoutNVX;
     stream->write(&opcode_vkCreateIndirectCommandsLayoutNVX, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateIndirectCommandsLayoutNVX, sizeof(uint32_t));
-    uint64_t cgen_var_1262;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1262, 1);
-    stream->write((uint64_t*)&cgen_var_1262, 1 * 8);
+    uint64_t cgen_var_1272;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1272, 1);
+    stream->write((uint64_t*)&cgen_var_1272, 1 * 8);
     marshal_VkIndirectCommandsLayoutCreateInfoNVX(stream, (VkIndirectCommandsLayoutCreateInfoNVX*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1263 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1263);
+    uint64_t cgen_var_1273 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1273);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1264;
-    stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1264, 1);
-    stream->write((uint64_t*)&cgen_var_1264, 8);
+    uint64_t cgen_var_1274;
+    stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1274, 1);
+    stream->write((uint64_t*)&cgen_var_1274, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_1265;
-    stream->read((uint64_t*)&cgen_var_1265, 8);
-    stream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_1265, (VkIndirectCommandsLayoutNVX*)pIndirectCommandsLayout, 1);
+    uint64_t cgen_var_1275;
+    stream->read((uint64_t*)&cgen_var_1275, 8);
+    stream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_1275, (VkIndirectCommandsLayoutNVX*)pIndirectCommandsLayout, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
     stream->read(&vkCreateIndirectCommandsLayoutNVX_VkResult_return, sizeof(VkResult));
@@ -18195,15 +18325,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1266;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1266, 1);
-        countingStream->write((uint64_t*)&cgen_var_1266, 1 * 8);
-        uint64_t cgen_var_1267;
-        countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1267, 1);
-        countingStream->write((uint64_t*)&cgen_var_1267, 1 * 8);
+        uint64_t cgen_var_1276;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1276, 1);
+        countingStream->write((uint64_t*)&cgen_var_1276, 1 * 8);
+        uint64_t cgen_var_1277;
+        countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1277, 1);
+        countingStream->write((uint64_t*)&cgen_var_1277, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1268 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1268);
+        uint64_t cgen_var_1278 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1278);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -18214,15 +18344,15 @@
     uint32_t opcode_vkDestroyIndirectCommandsLayoutNVX = OP_vkDestroyIndirectCommandsLayoutNVX;
     stream->write(&opcode_vkDestroyIndirectCommandsLayoutNVX, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyIndirectCommandsLayoutNVX, sizeof(uint32_t));
-    uint64_t cgen_var_1269;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1269, 1);
-    stream->write((uint64_t*)&cgen_var_1269, 1 * 8);
-    uint64_t cgen_var_1270;
-    stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1270, 1);
-    stream->write((uint64_t*)&cgen_var_1270, 1 * 8);
+    uint64_t cgen_var_1279;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1279, 1);
+    stream->write((uint64_t*)&cgen_var_1279, 1 * 8);
+    uint64_t cgen_var_1280;
+    stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1280, 1);
+    stream->write((uint64_t*)&cgen_var_1280, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1271 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1271);
+    uint64_t cgen_var_1281 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1281);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -18270,46 +18400,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1272;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1272, 1);
-        countingStream->write((uint64_t*)&cgen_var_1272, 1 * 8);
+        uint64_t cgen_var_1282;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1282, 1);
+        countingStream->write((uint64_t*)&cgen_var_1282, 1 * 8);
         marshal_VkObjectTableCreateInfoNVX(countingStream, (VkObjectTableCreateInfoNVX*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1273 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1273);
+        uint64_t cgen_var_1283 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1283);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1274;
-        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1274, 1);
-        countingStream->write((uint64_t*)&cgen_var_1274, 8);
+        uint64_t cgen_var_1284;
+        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1284, 1);
+        countingStream->write((uint64_t*)&cgen_var_1284, 8);
     }
     uint32_t packetSize_vkCreateObjectTableNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateObjectTableNVX = OP_vkCreateObjectTableNVX;
     stream->write(&opcode_vkCreateObjectTableNVX, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateObjectTableNVX, sizeof(uint32_t));
-    uint64_t cgen_var_1275;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1275, 1);
-    stream->write((uint64_t*)&cgen_var_1275, 1 * 8);
+    uint64_t cgen_var_1285;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1285, 1);
+    stream->write((uint64_t*)&cgen_var_1285, 1 * 8);
     marshal_VkObjectTableCreateInfoNVX(stream, (VkObjectTableCreateInfoNVX*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1276 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1276);
+    uint64_t cgen_var_1286 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1286);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1277;
-    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1277, 1);
-    stream->write((uint64_t*)&cgen_var_1277, 8);
+    uint64_t cgen_var_1287;
+    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1287, 1);
+    stream->write((uint64_t*)&cgen_var_1287, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_1278;
-    stream->read((uint64_t*)&cgen_var_1278, 8);
-    stream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_1278, (VkObjectTableNVX*)pObjectTable, 1);
+    uint64_t cgen_var_1288;
+    stream->read((uint64_t*)&cgen_var_1288, 8);
+    stream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_1288, (VkObjectTableNVX*)pObjectTable, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
     stream->read(&vkCreateObjectTableNVX_VkResult_return, sizeof(VkResult));
@@ -18349,15 +18479,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1279;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1279, 1);
-        countingStream->write((uint64_t*)&cgen_var_1279, 1 * 8);
-        uint64_t cgen_var_1280;
-        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1280, 1);
-        countingStream->write((uint64_t*)&cgen_var_1280, 1 * 8);
+        uint64_t cgen_var_1289;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1289, 1);
+        countingStream->write((uint64_t*)&cgen_var_1289, 1 * 8);
+        uint64_t cgen_var_1290;
+        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1290, 1);
+        countingStream->write((uint64_t*)&cgen_var_1290, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1281 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1281);
+        uint64_t cgen_var_1291 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1291);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -18368,15 +18498,15 @@
     uint32_t opcode_vkDestroyObjectTableNVX = OP_vkDestroyObjectTableNVX;
     stream->write(&opcode_vkDestroyObjectTableNVX, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyObjectTableNVX, sizeof(uint32_t));
-    uint64_t cgen_var_1282;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1282, 1);
-    stream->write((uint64_t*)&cgen_var_1282, 1 * 8);
-    uint64_t cgen_var_1283;
-    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1283, 1);
-    stream->write((uint64_t*)&cgen_var_1283, 1 * 8);
+    uint64_t cgen_var_1292;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1292, 1);
+    stream->write((uint64_t*)&cgen_var_1292, 1 * 8);
+    uint64_t cgen_var_1293;
+    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1293, 1);
+    stream->write((uint64_t*)&cgen_var_1293, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1284 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1284);
+    uint64_t cgen_var_1294 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1294);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -18415,12 +18545,12 @@
     (void)local_ppObjectTableEntries;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1285;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1285, 1);
-        countingStream->write((uint64_t*)&cgen_var_1285, 1 * 8);
-        uint64_t cgen_var_1286;
-        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1286, 1);
-        countingStream->write((uint64_t*)&cgen_var_1286, 1 * 8);
+        uint64_t cgen_var_1295;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1295, 1);
+        countingStream->write((uint64_t*)&cgen_var_1295, 1 * 8);
+        uint64_t cgen_var_1296;
+        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1296, 1);
+        countingStream->write((uint64_t*)&cgen_var_1296, 1 * 8);
         countingStream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
         (void)local_ppObjectTableEntries;
         countingStream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
@@ -18430,12 +18560,12 @@
     uint32_t opcode_vkRegisterObjectsNVX = OP_vkRegisterObjectsNVX;
     stream->write(&opcode_vkRegisterObjectsNVX, sizeof(uint32_t));
     stream->write(&packetSize_vkRegisterObjectsNVX, sizeof(uint32_t));
-    uint64_t cgen_var_1287;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1287, 1);
-    stream->write((uint64_t*)&cgen_var_1287, 1 * 8);
-    uint64_t cgen_var_1288;
-    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1288, 1);
-    stream->write((uint64_t*)&cgen_var_1288, 1 * 8);
+    uint64_t cgen_var_1297;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1297, 1);
+    stream->write((uint64_t*)&cgen_var_1297, 1 * 8);
+    uint64_t cgen_var_1298;
+    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1298, 1);
+    stream->write((uint64_t*)&cgen_var_1298, 1 * 8);
     stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
     (void)local_ppObjectTableEntries;
     stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
@@ -18481,12 +18611,12 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1289;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1289, 1);
-        countingStream->write((uint64_t*)&cgen_var_1289, 1 * 8);
-        uint64_t cgen_var_1290;
-        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1290, 1);
-        countingStream->write((uint64_t*)&cgen_var_1290, 1 * 8);
+        uint64_t cgen_var_1299;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1299, 1);
+        countingStream->write((uint64_t*)&cgen_var_1299, 1 * 8);
+        uint64_t cgen_var_1300;
+        countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1300, 1);
+        countingStream->write((uint64_t*)&cgen_var_1300, 1 * 8);
         countingStream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
         countingStream->write((VkObjectEntryTypeNVX*)local_pObjectEntryTypes, ((objectCount)) * sizeof(VkObjectEntryTypeNVX));
         countingStream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
@@ -18496,12 +18626,12 @@
     uint32_t opcode_vkUnregisterObjectsNVX = OP_vkUnregisterObjectsNVX;
     stream->write(&opcode_vkUnregisterObjectsNVX, sizeof(uint32_t));
     stream->write(&packetSize_vkUnregisterObjectsNVX, sizeof(uint32_t));
-    uint64_t cgen_var_1291;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1291, 1);
-    stream->write((uint64_t*)&cgen_var_1291, 1 * 8);
-    uint64_t cgen_var_1292;
-    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1292, 1);
-    stream->write((uint64_t*)&cgen_var_1292, 1 * 8);
+    uint64_t cgen_var_1301;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1301, 1);
+    stream->write((uint64_t*)&cgen_var_1301, 1 * 8);
+    uint64_t cgen_var_1302;
+    stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1302, 1);
+    stream->write((uint64_t*)&cgen_var_1302, 1 * 8);
     stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
     stream->write((VkObjectEntryTypeNVX*)local_pObjectEntryTypes, ((objectCount)) * sizeof(VkObjectEntryTypeNVX));
     stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
@@ -18529,9 +18659,9 @@
     local_physicalDevice = physicalDevice;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1293;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1293, 1);
-        countingStream->write((uint64_t*)&cgen_var_1293, 1 * 8);
+        uint64_t cgen_var_1303;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1303, 1);
+        countingStream->write((uint64_t*)&cgen_var_1303, 1 * 8);
         marshal_VkDeviceGeneratedCommandsFeaturesNVX(countingStream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
         marshal_VkDeviceGeneratedCommandsLimitsNVX(countingStream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
     }
@@ -18540,9 +18670,9 @@
     uint32_t opcode_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = OP_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
     stream->write(&opcode_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX, sizeof(uint32_t));
-    uint64_t cgen_var_1294;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1294, 1);
-    stream->write((uint64_t*)&cgen_var_1294, 1 * 8);
+    uint64_t cgen_var_1304;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1304, 1);
+    stream->write((uint64_t*)&cgen_var_1304, 1 * 8);
     marshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
     marshal_VkDeviceGeneratedCommandsLimitsNVX(stream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
     unmarshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
@@ -18597,9 +18727,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1295;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1295, 1);
-        countingStream->write((uint64_t*)&cgen_var_1295, 1 * 8);
+        uint64_t cgen_var_1305;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1305, 1);
+        countingStream->write((uint64_t*)&cgen_var_1305, 1 * 8);
         countingStream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
@@ -18612,9 +18742,9 @@
     uint32_t opcode_vkCmdSetViewportWScalingNV = OP_vkCmdSetViewportWScalingNV;
     stream->write(&opcode_vkCmdSetViewportWScalingNV, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetViewportWScalingNV, sizeof(uint32_t));
-    uint64_t cgen_var_1296;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1296, 1);
-    stream->write((uint64_t*)&cgen_var_1296, 1 * 8);
+    uint64_t cgen_var_1306;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1306, 1);
+    stream->write((uint64_t*)&cgen_var_1306, 1 * 8);
     stream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
     stream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
@@ -18642,24 +18772,24 @@
     local_display = display;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1297;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1297, 1);
-        countingStream->write((uint64_t*)&cgen_var_1297, 1 * 8);
-        uint64_t cgen_var_1298;
-        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1298, 1);
-        countingStream->write((uint64_t*)&cgen_var_1298, 1 * 8);
+        uint64_t cgen_var_1307;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1307, 1);
+        countingStream->write((uint64_t*)&cgen_var_1307, 1 * 8);
+        uint64_t cgen_var_1308;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1308, 1);
+        countingStream->write((uint64_t*)&cgen_var_1308, 1 * 8);
     }
     uint32_t packetSize_vkReleaseDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkReleaseDisplayEXT = OP_vkReleaseDisplayEXT;
     stream->write(&opcode_vkReleaseDisplayEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkReleaseDisplayEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1299;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1299, 1);
-    stream->write((uint64_t*)&cgen_var_1299, 1 * 8);
-    uint64_t cgen_var_1300;
-    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1300, 1);
-    stream->write((uint64_t*)&cgen_var_1300, 1 * 8);
+    uint64_t cgen_var_1309;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1309, 1);
+    stream->write((uint64_t*)&cgen_var_1309, 1 * 8);
+    uint64_t cgen_var_1310;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1310, 1);
+    stream->write((uint64_t*)&cgen_var_1310, 1 * 8);
     VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
     stream->read(&vkReleaseDisplayEXT_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -18688,26 +18818,26 @@
     local_display = display;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1301;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1301, 1);
-        countingStream->write((uint64_t*)&cgen_var_1301, 1 * 8);
+        uint64_t cgen_var_1311;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1311, 1);
+        countingStream->write((uint64_t*)&cgen_var_1311, 1 * 8);
         countingStream->write((Display*)dpy, sizeof(Display));
-        uint64_t cgen_var_1302;
-        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1302, 1);
-        countingStream->write((uint64_t*)&cgen_var_1302, 1 * 8);
+        uint64_t cgen_var_1312;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1312, 1);
+        countingStream->write((uint64_t*)&cgen_var_1312, 1 * 8);
     }
     uint32_t packetSize_vkAcquireXlibDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkAcquireXlibDisplayEXT = OP_vkAcquireXlibDisplayEXT;
     stream->write(&opcode_vkAcquireXlibDisplayEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkAcquireXlibDisplayEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1303;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1303, 1);
-    stream->write((uint64_t*)&cgen_var_1303, 1 * 8);
+    uint64_t cgen_var_1313;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1313, 1);
+    stream->write((uint64_t*)&cgen_var_1313, 1 * 8);
     stream->write((Display*)dpy, sizeof(Display));
-    uint64_t cgen_var_1304;
-    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1304, 1);
-    stream->write((uint64_t*)&cgen_var_1304, 1 * 8);
+    uint64_t cgen_var_1314;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1314, 1);
+    stream->write((uint64_t*)&cgen_var_1314, 1 * 8);
     stream->read((Display*)dpy, sizeof(Display));
     VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
     stream->read(&vkAcquireXlibDisplayEXT_VkResult_return, sizeof(VkResult));
@@ -18736,34 +18866,34 @@
     local_rrOutput = rrOutput;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1305;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1305, 1);
-        countingStream->write((uint64_t*)&cgen_var_1305, 1 * 8);
+        uint64_t cgen_var_1315;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1315, 1);
+        countingStream->write((uint64_t*)&cgen_var_1315, 1 * 8);
         countingStream->write((Display*)dpy, sizeof(Display));
         countingStream->write((RROutput*)&local_rrOutput, sizeof(RROutput));
-        uint64_t cgen_var_1306;
-        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1306, 1);
-        countingStream->write((uint64_t*)&cgen_var_1306, 8);
+        uint64_t cgen_var_1316;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1316, 1);
+        countingStream->write((uint64_t*)&cgen_var_1316, 8);
     }
     uint32_t packetSize_vkGetRandROutputDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkGetRandROutputDisplayEXT = OP_vkGetRandROutputDisplayEXT;
     stream->write(&opcode_vkGetRandROutputDisplayEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkGetRandROutputDisplayEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1307;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1307, 1);
-    stream->write((uint64_t*)&cgen_var_1307, 1 * 8);
+    uint64_t cgen_var_1317;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1317, 1);
+    stream->write((uint64_t*)&cgen_var_1317, 1 * 8);
     stream->write((Display*)dpy, sizeof(Display));
     stream->write((RROutput*)&local_rrOutput, sizeof(RROutput));
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1308;
-    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1308, 1);
-    stream->write((uint64_t*)&cgen_var_1308, 8);
+    uint64_t cgen_var_1318;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1318, 1);
+    stream->write((uint64_t*)&cgen_var_1318, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->read((Display*)dpy, sizeof(Display));
-    uint64_t cgen_var_1309;
-    stream->read((uint64_t*)&cgen_var_1309, 8);
-    stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_1309, (VkDisplayKHR*)pDisplay, 1);
+    uint64_t cgen_var_1319;
+    stream->read((uint64_t*)&cgen_var_1319, 8);
+    stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_1319, (VkDisplayKHR*)pDisplay, 1);
     VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetRandROutputDisplayEXT_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -18792,12 +18922,12 @@
     local_surface = surface;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1310;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1310, 1);
-        countingStream->write((uint64_t*)&cgen_var_1310, 1 * 8);
-        uint64_t cgen_var_1311;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1311, 1);
-        countingStream->write((uint64_t*)&cgen_var_1311, 1 * 8);
+        uint64_t cgen_var_1320;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1320, 1);
+        countingStream->write((uint64_t*)&cgen_var_1320, 1 * 8);
+        uint64_t cgen_var_1321;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1321, 1);
+        countingStream->write((uint64_t*)&cgen_var_1321, 1 * 8);
         marshal_VkSurfaceCapabilities2EXT(countingStream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
     }
     uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -18805,12 +18935,12 @@
     uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT = OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT;
     stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t));
-    uint64_t cgen_var_1312;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1312, 1);
-    stream->write((uint64_t*)&cgen_var_1312, 1 * 8);
-    uint64_t cgen_var_1313;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1313, 1);
-    stream->write((uint64_t*)&cgen_var_1313, 1 * 8);
+    uint64_t cgen_var_1322;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1322, 1);
+    stream->write((uint64_t*)&cgen_var_1322, 1 * 8);
+    uint64_t cgen_var_1323;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1323, 1);
+    stream->write((uint64_t*)&cgen_var_1323, 1 * 8);
     marshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
     unmarshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
     if (pSurfaceCapabilities)
@@ -18856,12 +18986,12 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1314;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1314, 1);
-        countingStream->write((uint64_t*)&cgen_var_1314, 1 * 8);
-        uint64_t cgen_var_1315;
-        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1315, 1);
-        countingStream->write((uint64_t*)&cgen_var_1315, 1 * 8);
+        uint64_t cgen_var_1324;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1324, 1);
+        countingStream->write((uint64_t*)&cgen_var_1324, 1 * 8);
+        uint64_t cgen_var_1325;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1325, 1);
+        countingStream->write((uint64_t*)&cgen_var_1325, 1 * 8);
         marshal_VkDisplayPowerInfoEXT(countingStream, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
     }
     uint32_t packetSize_vkDisplayPowerControlEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -18869,12 +18999,12 @@
     uint32_t opcode_vkDisplayPowerControlEXT = OP_vkDisplayPowerControlEXT;
     stream->write(&opcode_vkDisplayPowerControlEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkDisplayPowerControlEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1316;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1316, 1);
-    stream->write((uint64_t*)&cgen_var_1316, 1 * 8);
-    uint64_t cgen_var_1317;
-    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1317, 1);
-    stream->write((uint64_t*)&cgen_var_1317, 1 * 8);
+    uint64_t cgen_var_1326;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1326, 1);
+    stream->write((uint64_t*)&cgen_var_1326, 1 * 8);
+    uint64_t cgen_var_1327;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1327, 1);
+    stream->write((uint64_t*)&cgen_var_1327, 1 * 8);
     marshal_VkDisplayPowerInfoEXT(stream, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
     VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
     stream->read(&vkDisplayPowerControlEXT_VkResult_return, sizeof(VkResult));
@@ -18924,45 +19054,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1318;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1318, 1);
-        countingStream->write((uint64_t*)&cgen_var_1318, 1 * 8);
+        uint64_t cgen_var_1328;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1328, 1);
+        countingStream->write((uint64_t*)&cgen_var_1328, 1 * 8);
         marshal_VkDeviceEventInfoEXT(countingStream, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1319 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1319);
+        uint64_t cgen_var_1329 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1329);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1320;
-        countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1320, 1);
-        countingStream->write((uint64_t*)&cgen_var_1320, 8);
+        uint64_t cgen_var_1330;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1330, 1);
+        countingStream->write((uint64_t*)&cgen_var_1330, 8);
     }
     uint32_t packetSize_vkRegisterDeviceEventEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkRegisterDeviceEventEXT = OP_vkRegisterDeviceEventEXT;
     stream->write(&opcode_vkRegisterDeviceEventEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkRegisterDeviceEventEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1321;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1321, 1);
-    stream->write((uint64_t*)&cgen_var_1321, 1 * 8);
+    uint64_t cgen_var_1331;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1331, 1);
+    stream->write((uint64_t*)&cgen_var_1331, 1 * 8);
     marshal_VkDeviceEventInfoEXT(stream, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1322 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1322);
+    uint64_t cgen_var_1332 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1332);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1323;
-    stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1323, 1);
-    stream->write((uint64_t*)&cgen_var_1323, 8);
+    uint64_t cgen_var_1333;
+    stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1333, 1);
+    stream->write((uint64_t*)&cgen_var_1333, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_1324;
-    stream->read((uint64_t*)&cgen_var_1324, 8);
-    stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1324, (VkFence*)pFence, 1);
+    uint64_t cgen_var_1334;
+    stream->read((uint64_t*)&cgen_var_1334, 8);
+    stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1334, (VkFence*)pFence, 1);
     VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterDeviceEventEXT_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -19014,51 +19144,51 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1325;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1325, 1);
-        countingStream->write((uint64_t*)&cgen_var_1325, 1 * 8);
-        uint64_t cgen_var_1326;
-        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1326, 1);
-        countingStream->write((uint64_t*)&cgen_var_1326, 1 * 8);
+        uint64_t cgen_var_1335;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1335, 1);
+        countingStream->write((uint64_t*)&cgen_var_1335, 1 * 8);
+        uint64_t cgen_var_1336;
+        countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1336, 1);
+        countingStream->write((uint64_t*)&cgen_var_1336, 1 * 8);
         marshal_VkDisplayEventInfoEXT(countingStream, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1327 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1327);
+        uint64_t cgen_var_1337 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1337);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1328;
-        countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1328, 1);
-        countingStream->write((uint64_t*)&cgen_var_1328, 8);
+        uint64_t cgen_var_1338;
+        countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1338, 1);
+        countingStream->write((uint64_t*)&cgen_var_1338, 8);
     }
     uint32_t packetSize_vkRegisterDisplayEventEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkRegisterDisplayEventEXT = OP_vkRegisterDisplayEventEXT;
     stream->write(&opcode_vkRegisterDisplayEventEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkRegisterDisplayEventEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1329;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1329, 1);
-    stream->write((uint64_t*)&cgen_var_1329, 1 * 8);
-    uint64_t cgen_var_1330;
-    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1330, 1);
-    stream->write((uint64_t*)&cgen_var_1330, 1 * 8);
+    uint64_t cgen_var_1339;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1339, 1);
+    stream->write((uint64_t*)&cgen_var_1339, 1 * 8);
+    uint64_t cgen_var_1340;
+    stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1340, 1);
+    stream->write((uint64_t*)&cgen_var_1340, 1 * 8);
     marshal_VkDisplayEventInfoEXT(stream, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1331 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1331);
+    uint64_t cgen_var_1341 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1341);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1332;
-    stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1332, 1);
-    stream->write((uint64_t*)&cgen_var_1332, 8);
+    uint64_t cgen_var_1342;
+    stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1342, 1);
+    stream->write((uint64_t*)&cgen_var_1342, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_1333;
-    stream->read((uint64_t*)&cgen_var_1333, 8);
-    stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1333, (VkFence*)pFence, 1);
+    uint64_t cgen_var_1343;
+    stream->read((uint64_t*)&cgen_var_1343, 8);
+    stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1343, (VkFence*)pFence, 1);
     VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterDisplayEventEXT_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -19088,12 +19218,12 @@
     local_counter = counter;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1334;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1334, 1);
-        countingStream->write((uint64_t*)&cgen_var_1334, 1 * 8);
-        uint64_t cgen_var_1335;
-        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1335, 1);
-        countingStream->write((uint64_t*)&cgen_var_1335, 1 * 8);
+        uint64_t cgen_var_1344;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1344, 1);
+        countingStream->write((uint64_t*)&cgen_var_1344, 1 * 8);
+        uint64_t cgen_var_1345;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1345, 1);
+        countingStream->write((uint64_t*)&cgen_var_1345, 1 * 8);
         countingStream->write((VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT));
         countingStream->write((uint64_t*)pCounterValue, sizeof(uint64_t));
     }
@@ -19102,12 +19232,12 @@
     uint32_t opcode_vkGetSwapchainCounterEXT = OP_vkGetSwapchainCounterEXT;
     stream->write(&opcode_vkGetSwapchainCounterEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkGetSwapchainCounterEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1336;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1336, 1);
-    stream->write((uint64_t*)&cgen_var_1336, 1 * 8);
-    uint64_t cgen_var_1337;
-    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1337, 1);
-    stream->write((uint64_t*)&cgen_var_1337, 1 * 8);
+    uint64_t cgen_var_1346;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1346, 1);
+    stream->write((uint64_t*)&cgen_var_1346, 1 * 8);
+    uint64_t cgen_var_1347;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1347, 1);
+    stream->write((uint64_t*)&cgen_var_1347, 1 * 8);
     stream->write((VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT));
     stream->write((uint64_t*)pCounterValue, sizeof(uint64_t));
     stream->read((uint64_t*)pCounterValue, sizeof(uint64_t));
@@ -19139,12 +19269,12 @@
     local_swapchain = swapchain;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1338;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1338, 1);
-        countingStream->write((uint64_t*)&cgen_var_1338, 1 * 8);
-        uint64_t cgen_var_1339;
-        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1339, 1);
-        countingStream->write((uint64_t*)&cgen_var_1339, 1 * 8);
+        uint64_t cgen_var_1348;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1348, 1);
+        countingStream->write((uint64_t*)&cgen_var_1348, 1 * 8);
+        uint64_t cgen_var_1349;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1349, 1);
+        countingStream->write((uint64_t*)&cgen_var_1349, 1 * 8);
         marshal_VkRefreshCycleDurationGOOGLE(countingStream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
     }
     uint32_t packetSize_vkGetRefreshCycleDurationGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -19152,12 +19282,12 @@
     uint32_t opcode_vkGetRefreshCycleDurationGOOGLE = OP_vkGetRefreshCycleDurationGOOGLE;
     stream->write(&opcode_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t));
     stream->write(&packetSize_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t));
-    uint64_t cgen_var_1340;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1340, 1);
-    stream->write((uint64_t*)&cgen_var_1340, 1 * 8);
-    uint64_t cgen_var_1341;
-    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1341, 1);
-    stream->write((uint64_t*)&cgen_var_1341, 1 * 8);
+    uint64_t cgen_var_1350;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1350, 1);
+    stream->write((uint64_t*)&cgen_var_1350, 1 * 8);
+    uint64_t cgen_var_1351;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1351, 1);
+    stream->write((uint64_t*)&cgen_var_1351, 1 * 8);
     marshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
     unmarshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
     if (pDisplayTimingProperties)
@@ -19191,22 +19321,22 @@
     local_swapchain = swapchain;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1342;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1342, 1);
-        countingStream->write((uint64_t*)&cgen_var_1342, 1 * 8);
-        uint64_t cgen_var_1343;
-        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1343, 1);
-        countingStream->write((uint64_t*)&cgen_var_1343, 1 * 8);
+        uint64_t cgen_var_1352;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1352, 1);
+        countingStream->write((uint64_t*)&cgen_var_1352, 1 * 8);
+        uint64_t cgen_var_1353;
+        countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1353, 1);
+        countingStream->write((uint64_t*)&cgen_var_1353, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1344 = (uint64_t)(uintptr_t)pPresentationTimingCount;
-        countingStream->putBe64(cgen_var_1344);
+        uint64_t cgen_var_1354 = (uint64_t)(uintptr_t)pPresentationTimingCount;
+        countingStream->putBe64(cgen_var_1354);
         if (pPresentationTimingCount)
         {
             countingStream->write((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_1345 = (uint64_t)(uintptr_t)pPresentationTimings;
-        countingStream->putBe64(cgen_var_1345);
+        uint64_t cgen_var_1355 = (uint64_t)(uintptr_t)pPresentationTimings;
+        countingStream->putBe64(cgen_var_1355);
         if (pPresentationTimings)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
@@ -19220,22 +19350,22 @@
     uint32_t opcode_vkGetPastPresentationTimingGOOGLE = OP_vkGetPastPresentationTimingGOOGLE;
     stream->write(&opcode_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t));
-    uint64_t cgen_var_1346;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1346, 1);
-    stream->write((uint64_t*)&cgen_var_1346, 1 * 8);
-    uint64_t cgen_var_1347;
-    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1347, 1);
-    stream->write((uint64_t*)&cgen_var_1347, 1 * 8);
+    uint64_t cgen_var_1356;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1356, 1);
+    stream->write((uint64_t*)&cgen_var_1356, 1 * 8);
+    uint64_t cgen_var_1357;
+    stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1357, 1);
+    stream->write((uint64_t*)&cgen_var_1357, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1348 = (uint64_t)(uintptr_t)pPresentationTimingCount;
-    stream->putBe64(cgen_var_1348);
+    uint64_t cgen_var_1358 = (uint64_t)(uintptr_t)pPresentationTimingCount;
+    stream->putBe64(cgen_var_1358);
     if (pPresentationTimingCount)
     {
         stream->write((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_1349 = (uint64_t)(uintptr_t)pPresentationTimings;
-    stream->putBe64(cgen_var_1349);
+    uint64_t cgen_var_1359 = (uint64_t)(uintptr_t)pPresentationTimings;
+    stream->putBe64(cgen_var_1359);
     if (pPresentationTimings)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
@@ -19333,9 +19463,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1352;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1352, 1);
-        countingStream->write((uint64_t*)&cgen_var_1352, 1 * 8);
+        uint64_t cgen_var_1362;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1362, 1);
+        countingStream->write((uint64_t*)&cgen_var_1362, 1 * 8);
         countingStream->write((uint32_t*)&local_firstDiscardRectangle, sizeof(uint32_t));
         countingStream->write((uint32_t*)&local_discardRectangleCount, sizeof(uint32_t));
         for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
@@ -19348,9 +19478,9 @@
     uint32_t opcode_vkCmdSetDiscardRectangleEXT = OP_vkCmdSetDiscardRectangleEXT;
     stream->write(&opcode_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1353;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1353, 1);
-    stream->write((uint64_t*)&cgen_var_1353, 1 * 8);
+    uint64_t cgen_var_1363;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1363, 1);
+    stream->write((uint64_t*)&cgen_var_1363, 1 * 8);
     stream->write((uint32_t*)&local_firstDiscardRectangle, sizeof(uint32_t));
     stream->write((uint32_t*)&local_discardRectangleCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
@@ -19407,16 +19537,16 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1354;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1354, 1);
-        countingStream->write((uint64_t*)&cgen_var_1354, 1 * 8);
+        uint64_t cgen_var_1364;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1364, 1);
+        countingStream->write((uint64_t*)&cgen_var_1364, 1 * 8);
         countingStream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
         if (((swapchainCount)))
         {
-            uint64_t* cgen_var_1355;
-            countingStream->alloc((void**)&cgen_var_1355, ((swapchainCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1355, ((swapchainCount)));
-            countingStream->write((uint64_t*)cgen_var_1355, ((swapchainCount)) * 8);
+            uint64_t* cgen_var_1365;
+            countingStream->alloc((void**)&cgen_var_1365, ((swapchainCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1365, ((swapchainCount)));
+            countingStream->write((uint64_t*)cgen_var_1365, ((swapchainCount)) * 8);
         }
         for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
         {
@@ -19428,16 +19558,16 @@
     uint32_t opcode_vkSetHdrMetadataEXT = OP_vkSetHdrMetadataEXT;
     stream->write(&opcode_vkSetHdrMetadataEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkSetHdrMetadataEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1356;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1356, 1);
-    stream->write((uint64_t*)&cgen_var_1356, 1 * 8);
+    uint64_t cgen_var_1366;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1366, 1);
+    stream->write((uint64_t*)&cgen_var_1366, 1 * 8);
     stream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
     if (((swapchainCount)))
     {
-        uint64_t* cgen_var_1357;
-        stream->alloc((void**)&cgen_var_1357, ((swapchainCount)) * 8);
-        stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1357, ((swapchainCount)));
-        stream->write((uint64_t*)cgen_var_1357, ((swapchainCount)) * 8);
+        uint64_t* cgen_var_1367;
+        stream->alloc((void**)&cgen_var_1367, ((swapchainCount)) * 8);
+        stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1367, ((swapchainCount)));
+        stream->write((uint64_t*)cgen_var_1367, ((swapchainCount)) * 8);
     }
     for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
     {
@@ -19487,45 +19617,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1358;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1358, 1);
-        countingStream->write((uint64_t*)&cgen_var_1358, 1 * 8);
+        uint64_t cgen_var_1368;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1368, 1);
+        countingStream->write((uint64_t*)&cgen_var_1368, 1 * 8);
         marshal_VkIOSSurfaceCreateInfoMVK(countingStream, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1359 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1359);
+        uint64_t cgen_var_1369 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1369);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1360;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1360, 1);
-        countingStream->write((uint64_t*)&cgen_var_1360, 8);
+        uint64_t cgen_var_1370;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1370, 1);
+        countingStream->write((uint64_t*)&cgen_var_1370, 8);
     }
     uint32_t packetSize_vkCreateIOSSurfaceMVK = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateIOSSurfaceMVK = OP_vkCreateIOSSurfaceMVK;
     stream->write(&opcode_vkCreateIOSSurfaceMVK, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateIOSSurfaceMVK, sizeof(uint32_t));
-    uint64_t cgen_var_1361;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1361, 1);
-    stream->write((uint64_t*)&cgen_var_1361, 1 * 8);
+    uint64_t cgen_var_1371;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1371, 1);
+    stream->write((uint64_t*)&cgen_var_1371, 1 * 8);
     marshal_VkIOSSurfaceCreateInfoMVK(stream, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1362 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1362);
+    uint64_t cgen_var_1372 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1372);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1363;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1363, 1);
-    stream->write((uint64_t*)&cgen_var_1363, 8);
+    uint64_t cgen_var_1373;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1373, 1);
+    stream->write((uint64_t*)&cgen_var_1373, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_1364;
-    stream->read((uint64_t*)&cgen_var_1364, 8);
-    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1364, (VkSurfaceKHR*)pSurface, 1);
+    uint64_t cgen_var_1374;
+    stream->read((uint64_t*)&cgen_var_1374, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1374, (VkSurfaceKHR*)pSurface, 1);
     VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
     stream->read(&vkCreateIOSSurfaceMVK_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -19576,45 +19706,45 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1365;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1365, 1);
-        countingStream->write((uint64_t*)&cgen_var_1365, 1 * 8);
+        uint64_t cgen_var_1375;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1375, 1);
+        countingStream->write((uint64_t*)&cgen_var_1375, 1 * 8);
         marshal_VkMacOSSurfaceCreateInfoMVK(countingStream, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1366 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1366);
+        uint64_t cgen_var_1376 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1376);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1367;
-        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1367, 1);
-        countingStream->write((uint64_t*)&cgen_var_1367, 8);
+        uint64_t cgen_var_1377;
+        countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1377, 1);
+        countingStream->write((uint64_t*)&cgen_var_1377, 8);
     }
     uint32_t packetSize_vkCreateMacOSSurfaceMVK = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateMacOSSurfaceMVK = OP_vkCreateMacOSSurfaceMVK;
     stream->write(&opcode_vkCreateMacOSSurfaceMVK, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateMacOSSurfaceMVK, sizeof(uint32_t));
-    uint64_t cgen_var_1368;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1368, 1);
-    stream->write((uint64_t*)&cgen_var_1368, 1 * 8);
+    uint64_t cgen_var_1378;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1378, 1);
+    stream->write((uint64_t*)&cgen_var_1378, 1 * 8);
     marshal_VkMacOSSurfaceCreateInfoMVK(stream, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1369 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1369);
+    uint64_t cgen_var_1379 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1379);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1370;
-    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1370, 1);
-    stream->write((uint64_t*)&cgen_var_1370, 8);
+    uint64_t cgen_var_1380;
+    stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1380, 1);
+    stream->write((uint64_t*)&cgen_var_1380, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    uint64_t cgen_var_1371;
-    stream->read((uint64_t*)&cgen_var_1371, 8);
-    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1371, (VkSurfaceKHR*)pSurface, 1);
+    uint64_t cgen_var_1381;
+    stream->read((uint64_t*)&cgen_var_1381, 8);
+    stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1381, (VkSurfaceKHR*)pSurface, 1);
     VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
     stream->read(&vkCreateMacOSSurfaceMVK_VkResult_return, sizeof(VkResult));
     countingStream->clearPool();
@@ -19655,9 +19785,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1372;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1372, 1);
-        countingStream->write((uint64_t*)&cgen_var_1372, 1 * 8);
+        uint64_t cgen_var_1382;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1382, 1);
+        countingStream->write((uint64_t*)&cgen_var_1382, 1 * 8);
         marshal_VkDebugUtilsObjectNameInfoEXT(countingStream, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
     }
     uint32_t packetSize_vkSetDebugUtilsObjectNameEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -19665,9 +19795,9 @@
     uint32_t opcode_vkSetDebugUtilsObjectNameEXT = OP_vkSetDebugUtilsObjectNameEXT;
     stream->write(&opcode_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1373;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1373, 1);
-    stream->write((uint64_t*)&cgen_var_1373, 1 * 8);
+    uint64_t cgen_var_1383;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1383, 1);
+    stream->write((uint64_t*)&cgen_var_1383, 1 * 8);
     marshal_VkDebugUtilsObjectNameInfoEXT(stream, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
     VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
     stream->read(&vkSetDebugUtilsObjectNameEXT_VkResult_return, sizeof(VkResult));
@@ -19703,9 +19833,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1374;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1374, 1);
-        countingStream->write((uint64_t*)&cgen_var_1374, 1 * 8);
+        uint64_t cgen_var_1384;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1384, 1);
+        countingStream->write((uint64_t*)&cgen_var_1384, 1 * 8);
         marshal_VkDebugUtilsObjectTagInfoEXT(countingStream, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
     }
     uint32_t packetSize_vkSetDebugUtilsObjectTagEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -19713,9 +19843,9 @@
     uint32_t opcode_vkSetDebugUtilsObjectTagEXT = OP_vkSetDebugUtilsObjectTagEXT;
     stream->write(&opcode_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1375;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1375, 1);
-    stream->write((uint64_t*)&cgen_var_1375, 1 * 8);
+    uint64_t cgen_var_1385;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1385, 1);
+    stream->write((uint64_t*)&cgen_var_1385, 1 * 8);
     marshal_VkDebugUtilsObjectTagInfoEXT(stream, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
     VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
     stream->read(&vkSetDebugUtilsObjectTagEXT_VkResult_return, sizeof(VkResult));
@@ -19751,9 +19881,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1376;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1376, 1);
-        countingStream->write((uint64_t*)&cgen_var_1376, 1 * 8);
+        uint64_t cgen_var_1386;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1386, 1);
+        countingStream->write((uint64_t*)&cgen_var_1386, 1 * 8);
         marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     }
     uint32_t packetSize_vkQueueBeginDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -19761,9 +19891,9 @@
     uint32_t opcode_vkQueueBeginDebugUtilsLabelEXT = OP_vkQueueBeginDebugUtilsLabelEXT;
     stream->write(&opcode_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1377;
-    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1377, 1);
-    stream->write((uint64_t*)&cgen_var_1377, 1 * 8);
+    uint64_t cgen_var_1387;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1387, 1);
+    stream->write((uint64_t*)&cgen_var_1387, 1 * 8);
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     mImpl->log("finish vkQueueBeginDebugUtilsLabelEXT");;
 }
@@ -19781,18 +19911,18 @@
     local_queue = queue;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1378;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1378, 1);
-        countingStream->write((uint64_t*)&cgen_var_1378, 1 * 8);
+        uint64_t cgen_var_1388;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1388, 1);
+        countingStream->write((uint64_t*)&cgen_var_1388, 1 * 8);
     }
     uint32_t packetSize_vkQueueEndDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkQueueEndDebugUtilsLabelEXT = OP_vkQueueEndDebugUtilsLabelEXT;
     stream->write(&opcode_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1379;
-    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1379, 1);
-    stream->write((uint64_t*)&cgen_var_1379, 1 * 8);
+    uint64_t cgen_var_1389;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1389, 1);
+    stream->write((uint64_t*)&cgen_var_1389, 1 * 8);
     mImpl->log("finish vkQueueEndDebugUtilsLabelEXT");;
 }
 
@@ -19821,9 +19951,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1380;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1380, 1);
-        countingStream->write((uint64_t*)&cgen_var_1380, 1 * 8);
+        uint64_t cgen_var_1390;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1390, 1);
+        countingStream->write((uint64_t*)&cgen_var_1390, 1 * 8);
         marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     }
     uint32_t packetSize_vkQueueInsertDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -19831,9 +19961,9 @@
     uint32_t opcode_vkQueueInsertDebugUtilsLabelEXT = OP_vkQueueInsertDebugUtilsLabelEXT;
     stream->write(&opcode_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1381;
-    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1381, 1);
-    stream->write((uint64_t*)&cgen_var_1381, 1 * 8);
+    uint64_t cgen_var_1391;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1391, 1);
+    stream->write((uint64_t*)&cgen_var_1391, 1 * 8);
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     mImpl->log("finish vkQueueInsertDebugUtilsLabelEXT");;
 }
@@ -19863,9 +19993,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1382;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1382, 1);
-        countingStream->write((uint64_t*)&cgen_var_1382, 1 * 8);
+        uint64_t cgen_var_1392;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1392, 1);
+        countingStream->write((uint64_t*)&cgen_var_1392, 1 * 8);
         marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     }
     uint32_t packetSize_vkCmdBeginDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -19873,9 +20003,9 @@
     uint32_t opcode_vkCmdBeginDebugUtilsLabelEXT = OP_vkCmdBeginDebugUtilsLabelEXT;
     stream->write(&opcode_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1383;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1383, 1);
-    stream->write((uint64_t*)&cgen_var_1383, 1 * 8);
+    uint64_t cgen_var_1393;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1393, 1);
+    stream->write((uint64_t*)&cgen_var_1393, 1 * 8);
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     mImpl->log("finish vkCmdBeginDebugUtilsLabelEXT");;
 }
@@ -19893,18 +20023,18 @@
     local_commandBuffer = commandBuffer;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1384;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1384, 1);
-        countingStream->write((uint64_t*)&cgen_var_1384, 1 * 8);
+        uint64_t cgen_var_1394;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1394, 1);
+        countingStream->write((uint64_t*)&cgen_var_1394, 1 * 8);
     }
     uint32_t packetSize_vkCmdEndDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCmdEndDebugUtilsLabelEXT = OP_vkCmdEndDebugUtilsLabelEXT;
     stream->write(&opcode_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1385;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1385, 1);
-    stream->write((uint64_t*)&cgen_var_1385, 1 * 8);
+    uint64_t cgen_var_1395;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1395, 1);
+    stream->write((uint64_t*)&cgen_var_1395, 1 * 8);
     mImpl->log("finish vkCmdEndDebugUtilsLabelEXT");;
 }
 
@@ -19933,9 +20063,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1386;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1386, 1);
-        countingStream->write((uint64_t*)&cgen_var_1386, 1 * 8);
+        uint64_t cgen_var_1396;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1396, 1);
+        countingStream->write((uint64_t*)&cgen_var_1396, 1 * 8);
         marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     }
     uint32_t packetSize_vkCmdInsertDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -19943,9 +20073,9 @@
     uint32_t opcode_vkCmdInsertDebugUtilsLabelEXT = OP_vkCmdInsertDebugUtilsLabelEXT;
     stream->write(&opcode_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1387;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1387, 1);
-    stream->write((uint64_t*)&cgen_var_1387, 1 * 8);
+    uint64_t cgen_var_1397;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1397, 1);
+    stream->write((uint64_t*)&cgen_var_1397, 1 * 8);
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
     mImpl->log("finish vkCmdInsertDebugUtilsLabelEXT");;
 }
@@ -19989,46 +20119,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1388;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1388, 1);
-        countingStream->write((uint64_t*)&cgen_var_1388, 1 * 8);
+        uint64_t cgen_var_1398;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1398, 1);
+        countingStream->write((uint64_t*)&cgen_var_1398, 1 * 8);
         marshal_VkDebugUtilsMessengerCreateInfoEXT(countingStream, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1389 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1389);
+        uint64_t cgen_var_1399 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1399);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1390;
-        countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1390, 1);
-        countingStream->write((uint64_t*)&cgen_var_1390, 8);
+        uint64_t cgen_var_1400;
+        countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1400, 1);
+        countingStream->write((uint64_t*)&cgen_var_1400, 8);
     }
     uint32_t packetSize_vkCreateDebugUtilsMessengerEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateDebugUtilsMessengerEXT = OP_vkCreateDebugUtilsMessengerEXT;
     stream->write(&opcode_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1391;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1391, 1);
-    stream->write((uint64_t*)&cgen_var_1391, 1 * 8);
+    uint64_t cgen_var_1401;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1401, 1);
+    stream->write((uint64_t*)&cgen_var_1401, 1 * 8);
     marshal_VkDebugUtilsMessengerCreateInfoEXT(stream, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1392 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1392);
+    uint64_t cgen_var_1402 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1402);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1393;
-    stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1393, 1);
-    stream->write((uint64_t*)&cgen_var_1393, 8);
+    uint64_t cgen_var_1403;
+    stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1403, 1);
+    stream->write((uint64_t*)&cgen_var_1403, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_1394;
-    stream->read((uint64_t*)&cgen_var_1394, 8);
-    stream->handleMapping()->mapHandles_u64_VkDebugUtilsMessengerEXT(&cgen_var_1394, (VkDebugUtilsMessengerEXT*)pMessenger, 1);
+    uint64_t cgen_var_1404;
+    stream->read((uint64_t*)&cgen_var_1404, 8);
+    stream->handleMapping()->mapHandles_u64_VkDebugUtilsMessengerEXT(&cgen_var_1404, (VkDebugUtilsMessengerEXT*)pMessenger, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDebugUtilsMessengerEXT_VkResult_return, sizeof(VkResult));
@@ -20068,15 +20198,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1395;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1395, 1);
-        countingStream->write((uint64_t*)&cgen_var_1395, 1 * 8);
-        uint64_t cgen_var_1396;
-        countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1396, 1);
-        countingStream->write((uint64_t*)&cgen_var_1396, 1 * 8);
+        uint64_t cgen_var_1405;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1405, 1);
+        countingStream->write((uint64_t*)&cgen_var_1405, 1 * 8);
+        uint64_t cgen_var_1406;
+        countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1406, 1);
+        countingStream->write((uint64_t*)&cgen_var_1406, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1397 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1397);
+        uint64_t cgen_var_1407 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1407);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -20087,15 +20217,15 @@
     uint32_t opcode_vkDestroyDebugUtilsMessengerEXT = OP_vkDestroyDebugUtilsMessengerEXT;
     stream->write(&opcode_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1398;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1398, 1);
-    stream->write((uint64_t*)&cgen_var_1398, 1 * 8);
-    uint64_t cgen_var_1399;
-    stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1399, 1);
-    stream->write((uint64_t*)&cgen_var_1399, 1 * 8);
+    uint64_t cgen_var_1408;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1408, 1);
+    stream->write((uint64_t*)&cgen_var_1408, 1 * 8);
+    uint64_t cgen_var_1409;
+    stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1409, 1);
+    stream->write((uint64_t*)&cgen_var_1409, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1400 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1400);
+    uint64_t cgen_var_1410 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1410);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -20135,9 +20265,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1401;
-        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1401, 1);
-        countingStream->write((uint64_t*)&cgen_var_1401, 1 * 8);
+        uint64_t cgen_var_1411;
+        countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1411, 1);
+        countingStream->write((uint64_t*)&cgen_var_1411, 1 * 8);
         countingStream->write((VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
         countingStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
         marshal_VkDebugUtilsMessengerCallbackDataEXT(countingStream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
@@ -20147,9 +20277,9 @@
     uint32_t opcode_vkSubmitDebugUtilsMessageEXT = OP_vkSubmitDebugUtilsMessageEXT;
     stream->write(&opcode_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1402;
-    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1402, 1);
-    stream->write((uint64_t*)&cgen_var_1402, 1 * 8);
+    uint64_t cgen_var_1412;
+    stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1412, 1);
+    stream->write((uint64_t*)&cgen_var_1412, 1 * 8);
     stream->write((VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
     stream->write((VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
     marshal_VkDebugUtilsMessengerCallbackDataEXT(stream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
@@ -20179,9 +20309,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1403;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1403, 1);
-        countingStream->write((uint64_t*)&cgen_var_1403, 1 * 8);
+        uint64_t cgen_var_1413;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1413, 1);
+        countingStream->write((uint64_t*)&cgen_var_1413, 1 * 8);
         countingStream->write((AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
         marshal_VkAndroidHardwareBufferPropertiesANDROID(countingStream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
     }
@@ -20190,9 +20320,9 @@
     uint32_t opcode_vkGetAndroidHardwareBufferPropertiesANDROID = OP_vkGetAndroidHardwareBufferPropertiesANDROID;
     stream->write(&opcode_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t));
     stream->write(&packetSize_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t));
-    uint64_t cgen_var_1404;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1404, 1);
-    stream->write((uint64_t*)&cgen_var_1404, 1 * 8);
+    uint64_t cgen_var_1414;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1414, 1);
+    stream->write((uint64_t*)&cgen_var_1414, 1 * 8);
     stream->write((AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
     marshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
     unmarshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
@@ -20235,9 +20365,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1405;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1405, 1);
-        countingStream->write((uint64_t*)&cgen_var_1405, 1 * 8);
+        uint64_t cgen_var_1415;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1415, 1);
+        countingStream->write((uint64_t*)&cgen_var_1415, 1 * 8);
         marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(countingStream, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
         countingStream->write((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
     }
@@ -20246,9 +20376,9 @@
     uint32_t opcode_vkGetMemoryAndroidHardwareBufferANDROID = OP_vkGetMemoryAndroidHardwareBufferANDROID;
     stream->write(&opcode_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t));
     stream->write(&packetSize_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t));
-    uint64_t cgen_var_1406;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1406, 1);
-    stream->write((uint64_t*)&cgen_var_1406, 1 * 8);
+    uint64_t cgen_var_1416;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1416, 1);
+    stream->write((uint64_t*)&cgen_var_1416, 1 * 8);
     marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(stream, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
     stream->write((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
     stream->read((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
@@ -20298,9 +20428,9 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1407;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1407, 1);
-        countingStream->write((uint64_t*)&cgen_var_1407, 1 * 8);
+        uint64_t cgen_var_1417;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1417, 1);
+        countingStream->write((uint64_t*)&cgen_var_1417, 1 * 8);
         marshal_VkSampleLocationsInfoEXT(countingStream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
     }
     uint32_t packetSize_vkCmdSetSampleLocationsEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -20308,9 +20438,9 @@
     uint32_t opcode_vkCmdSetSampleLocationsEXT = OP_vkCmdSetSampleLocationsEXT;
     stream->write(&opcode_vkCmdSetSampleLocationsEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetSampleLocationsEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1408;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1408, 1);
-    stream->write((uint64_t*)&cgen_var_1408, 1 * 8);
+    uint64_t cgen_var_1418;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1418, 1);
+    stream->write((uint64_t*)&cgen_var_1418, 1 * 8);
     marshal_VkSampleLocationsInfoEXT(stream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
     mImpl->log("finish vkCmdSetSampleLocationsEXT");;
 }
@@ -20332,9 +20462,9 @@
     local_samples = samples;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1409;
-        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1409, 1);
-        countingStream->write((uint64_t*)&cgen_var_1409, 1 * 8);
+        uint64_t cgen_var_1419;
+        countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1419, 1);
+        countingStream->write((uint64_t*)&cgen_var_1419, 1 * 8);
         countingStream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
         marshal_VkMultisamplePropertiesEXT(countingStream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
     }
@@ -20343,9 +20473,9 @@
     uint32_t opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT = OP_vkGetPhysicalDeviceMultisamplePropertiesEXT;
     stream->write(&opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1410;
-    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1410, 1);
-    stream->write((uint64_t*)&cgen_var_1410, 1 * 8);
+    uint64_t cgen_var_1420;
+    stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1420, 1);
+    stream->write((uint64_t*)&cgen_var_1420, 1 * 8);
     stream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
     marshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
     unmarshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
@@ -20407,46 +20537,46 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1411;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1411, 1);
-        countingStream->write((uint64_t*)&cgen_var_1411, 1 * 8);
+        uint64_t cgen_var_1421;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1421, 1);
+        countingStream->write((uint64_t*)&cgen_var_1421, 1 * 8);
         marshal_VkValidationCacheCreateInfoEXT(countingStream, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1412 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1412);
+        uint64_t cgen_var_1422 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1422);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
         }
-        uint64_t cgen_var_1413;
-        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1413, 1);
-        countingStream->write((uint64_t*)&cgen_var_1413, 8);
+        uint64_t cgen_var_1423;
+        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1423, 1);
+        countingStream->write((uint64_t*)&cgen_var_1423, 8);
     }
     uint32_t packetSize_vkCreateValidationCacheEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
     countingStream->rewind();
     uint32_t opcode_vkCreateValidationCacheEXT = OP_vkCreateValidationCacheEXT;
     stream->write(&opcode_vkCreateValidationCacheEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkCreateValidationCacheEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1414;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1414, 1);
-    stream->write((uint64_t*)&cgen_var_1414, 1 * 8);
+    uint64_t cgen_var_1424;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1424, 1);
+    stream->write((uint64_t*)&cgen_var_1424, 1 * 8);
     marshal_VkValidationCacheCreateInfoEXT(stream, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1415 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1415);
+    uint64_t cgen_var_1425 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1425);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
     stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
-    uint64_t cgen_var_1416;
-    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1416, 1);
-    stream->write((uint64_t*)&cgen_var_1416, 8);
+    uint64_t cgen_var_1426;
+    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1426, 1);
+    stream->write((uint64_t*)&cgen_var_1426, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     stream->setHandleMapping(resources->createMapping());
-    uint64_t cgen_var_1417;
-    stream->read((uint64_t*)&cgen_var_1417, 8);
-    stream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_1417, (VkValidationCacheEXT*)pValidationCache, 1);
+    uint64_t cgen_var_1427;
+    stream->read((uint64_t*)&cgen_var_1427, 8);
+    stream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_1427, (VkValidationCacheEXT*)pValidationCache, 1);
     stream->unsetHandleMapping();
     VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
     stream->read(&vkCreateValidationCacheEXT_VkResult_return, sizeof(VkResult));
@@ -20486,15 +20616,15 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1418;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1418, 1);
-        countingStream->write((uint64_t*)&cgen_var_1418, 1 * 8);
-        uint64_t cgen_var_1419;
-        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1419, 1);
-        countingStream->write((uint64_t*)&cgen_var_1419, 1 * 8);
+        uint64_t cgen_var_1428;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1428, 1);
+        countingStream->write((uint64_t*)&cgen_var_1428, 1 * 8);
+        uint64_t cgen_var_1429;
+        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1429, 1);
+        countingStream->write((uint64_t*)&cgen_var_1429, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1420 = (uint64_t)(uintptr_t)local_pAllocator;
-        countingStream->putBe64(cgen_var_1420);
+        uint64_t cgen_var_1430 = (uint64_t)(uintptr_t)local_pAllocator;
+        countingStream->putBe64(cgen_var_1430);
         if (local_pAllocator)
         {
             marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -20505,15 +20635,15 @@
     uint32_t opcode_vkDestroyValidationCacheEXT = OP_vkDestroyValidationCacheEXT;
     stream->write(&opcode_vkDestroyValidationCacheEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkDestroyValidationCacheEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1421;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1421, 1);
-    stream->write((uint64_t*)&cgen_var_1421, 1 * 8);
-    uint64_t cgen_var_1422;
-    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1422, 1);
-    stream->write((uint64_t*)&cgen_var_1422, 1 * 8);
+    uint64_t cgen_var_1431;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1431, 1);
+    stream->write((uint64_t*)&cgen_var_1431, 1 * 8);
+    uint64_t cgen_var_1432;
+    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1432, 1);
+    stream->write((uint64_t*)&cgen_var_1432, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1423 = (uint64_t)(uintptr_t)local_pAllocator;
-    stream->putBe64(cgen_var_1423);
+    uint64_t cgen_var_1433 = (uint64_t)(uintptr_t)local_pAllocator;
+    stream->putBe64(cgen_var_1433);
     if (local_pAllocator)
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -20548,19 +20678,19 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1424;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1424, 1);
-        countingStream->write((uint64_t*)&cgen_var_1424, 1 * 8);
-        uint64_t cgen_var_1425;
-        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1425, 1);
-        countingStream->write((uint64_t*)&cgen_var_1425, 1 * 8);
+        uint64_t cgen_var_1434;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1434, 1);
+        countingStream->write((uint64_t*)&cgen_var_1434, 1 * 8);
+        uint64_t cgen_var_1435;
+        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1435, 1);
+        countingStream->write((uint64_t*)&cgen_var_1435, 1 * 8);
         countingStream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
         if (((srcCacheCount)))
         {
-            uint64_t* cgen_var_1426;
-            countingStream->alloc((void**)&cgen_var_1426, ((srcCacheCount)) * 8);
-            countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1426, ((srcCacheCount)));
-            countingStream->write((uint64_t*)cgen_var_1426, ((srcCacheCount)) * 8);
+            uint64_t* cgen_var_1436;
+            countingStream->alloc((void**)&cgen_var_1436, ((srcCacheCount)) * 8);
+            countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1436, ((srcCacheCount)));
+            countingStream->write((uint64_t*)cgen_var_1436, ((srcCacheCount)) * 8);
         }
     }
     uint32_t packetSize_vkMergeValidationCachesEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -20568,19 +20698,19 @@
     uint32_t opcode_vkMergeValidationCachesEXT = OP_vkMergeValidationCachesEXT;
     stream->write(&opcode_vkMergeValidationCachesEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkMergeValidationCachesEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1427;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1427, 1);
-    stream->write((uint64_t*)&cgen_var_1427, 1 * 8);
-    uint64_t cgen_var_1428;
-    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1428, 1);
-    stream->write((uint64_t*)&cgen_var_1428, 1 * 8);
+    uint64_t cgen_var_1437;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1437, 1);
+    stream->write((uint64_t*)&cgen_var_1437, 1 * 8);
+    uint64_t cgen_var_1438;
+    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1438, 1);
+    stream->write((uint64_t*)&cgen_var_1438, 1 * 8);
     stream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
     if (((srcCacheCount)))
     {
-        uint64_t* cgen_var_1429;
-        stream->alloc((void**)&cgen_var_1429, ((srcCacheCount)) * 8);
-        stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1429, ((srcCacheCount)));
-        stream->write((uint64_t*)cgen_var_1429, ((srcCacheCount)) * 8);
+        uint64_t* cgen_var_1439;
+        stream->alloc((void**)&cgen_var_1439, ((srcCacheCount)) * 8);
+        stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1439, ((srcCacheCount)));
+        stream->write((uint64_t*)cgen_var_1439, ((srcCacheCount)) * 8);
     }
     VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
     stream->read(&vkMergeValidationCachesEXT_VkResult_return, sizeof(VkResult));
@@ -20609,23 +20739,23 @@
     local_validationCache = validationCache;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1430;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1430, 1);
-        countingStream->write((uint64_t*)&cgen_var_1430, 1 * 8);
-        uint64_t cgen_var_1431;
-        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1431, 1);
-        countingStream->write((uint64_t*)&cgen_var_1431, 1 * 8);
+        uint64_t cgen_var_1440;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1440, 1);
+        countingStream->write((uint64_t*)&cgen_var_1440, 1 * 8);
+        uint64_t cgen_var_1441;
+        countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1441, 1);
+        countingStream->write((uint64_t*)&cgen_var_1441, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1432 = (uint64_t)(uintptr_t)pDataSize;
-        countingStream->putBe64(cgen_var_1432);
+        uint64_t cgen_var_1442 = (uint64_t)(uintptr_t)pDataSize;
+        countingStream->putBe64(cgen_var_1442);
         if (pDataSize)
         {
-            uint64_t cgen_var_1433 = (uint64_t)(*pDataSize);
-            countingStream->putBe64(cgen_var_1433);
+            uint64_t cgen_var_1443 = (uint64_t)(*pDataSize);
+            countingStream->putBe64(cgen_var_1443);
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_1434 = (uint64_t)(uintptr_t)pData;
-        countingStream->putBe64(cgen_var_1434);
+        uint64_t cgen_var_1444 = (uint64_t)(uintptr_t)pData;
+        countingStream->putBe64(cgen_var_1444);
         if (pData)
         {
             countingStream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
@@ -20636,23 +20766,23 @@
     uint32_t opcode_vkGetValidationCacheDataEXT = OP_vkGetValidationCacheDataEXT;
     stream->write(&opcode_vkGetValidationCacheDataEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkGetValidationCacheDataEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1435;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1435, 1);
-    stream->write((uint64_t*)&cgen_var_1435, 1 * 8);
-    uint64_t cgen_var_1436;
-    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1436, 1);
-    stream->write((uint64_t*)&cgen_var_1436, 1 * 8);
+    uint64_t cgen_var_1445;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1445, 1);
+    stream->write((uint64_t*)&cgen_var_1445, 1 * 8);
+    uint64_t cgen_var_1446;
+    stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1446, 1);
+    stream->write((uint64_t*)&cgen_var_1446, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1437 = (uint64_t)(uintptr_t)pDataSize;
-    stream->putBe64(cgen_var_1437);
+    uint64_t cgen_var_1447 = (uint64_t)(uintptr_t)pDataSize;
+    stream->putBe64(cgen_var_1447);
     if (pDataSize)
     {
-        uint64_t cgen_var_1438 = (uint64_t)(*pDataSize);
-        stream->putBe64(cgen_var_1438);
+        uint64_t cgen_var_1448 = (uint64_t)(*pDataSize);
+        stream->putBe64(cgen_var_1448);
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_1439 = (uint64_t)(uintptr_t)pData;
-    stream->putBe64(cgen_var_1439);
+    uint64_t cgen_var_1449 = (uint64_t)(uintptr_t)pData;
+    stream->putBe64(cgen_var_1449);
     if (pData)
     {
         stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
@@ -20720,13 +20850,13 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1443;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1443, 1);
-        countingStream->write((uint64_t*)&cgen_var_1443, 1 * 8);
+        uint64_t cgen_var_1453;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1453, 1);
+        countingStream->write((uint64_t*)&cgen_var_1453, 1 * 8);
         countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
         // WARNING PTR CHECK
-        uint64_t cgen_var_1444 = (uint64_t)(uintptr_t)local_pHostPointer;
-        countingStream->putBe64(cgen_var_1444);
+        uint64_t cgen_var_1454 = (uint64_t)(uintptr_t)local_pHostPointer;
+        countingStream->putBe64(cgen_var_1454);
         if (local_pHostPointer)
         {
             countingStream->write((void*)local_pHostPointer, sizeof(uint8_t));
@@ -20738,13 +20868,13 @@
     uint32_t opcode_vkGetMemoryHostPointerPropertiesEXT = OP_vkGetMemoryHostPointerPropertiesEXT;
     stream->write(&opcode_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t));
     stream->write(&packetSize_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t));
-    uint64_t cgen_var_1445;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1445, 1);
-    stream->write((uint64_t*)&cgen_var_1445, 1 * 8);
+    uint64_t cgen_var_1455;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1455, 1);
+    stream->write((uint64_t*)&cgen_var_1455, 1 * 8);
     stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1446 = (uint64_t)(uintptr_t)local_pHostPointer;
-    stream->putBe64(cgen_var_1446);
+    uint64_t cgen_var_1456 = (uint64_t)(uintptr_t)local_pHostPointer;
+    stream->putBe64(cgen_var_1456);
     if (local_pHostPointer)
     {
         stream->write((void*)local_pHostPointer, sizeof(uint8_t));
@@ -20791,13 +20921,13 @@
     local_marker = marker;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1447;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1447, 1);
-        countingStream->write((uint64_t*)&cgen_var_1447, 1 * 8);
+        uint64_t cgen_var_1457;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1457, 1);
+        countingStream->write((uint64_t*)&cgen_var_1457, 1 * 8);
         countingStream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
-        uint64_t cgen_var_1448;
-        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1448, 1);
-        countingStream->write((uint64_t*)&cgen_var_1448, 1 * 8);
+        uint64_t cgen_var_1458;
+        countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1458, 1);
+        countingStream->write((uint64_t*)&cgen_var_1458, 1 * 8);
         countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
         countingStream->write((uint32_t*)&local_marker, sizeof(uint32_t));
     }
@@ -20806,13 +20936,13 @@
     uint32_t opcode_vkCmdWriteBufferMarkerAMD = OP_vkCmdWriteBufferMarkerAMD;
     stream->write(&opcode_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t));
-    uint64_t cgen_var_1449;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1449, 1);
-    stream->write((uint64_t*)&cgen_var_1449, 1 * 8);
+    uint64_t cgen_var_1459;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1459, 1);
+    stream->write((uint64_t*)&cgen_var_1459, 1 * 8);
     stream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
-    uint64_t cgen_var_1450;
-    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1450, 1);
-    stream->write((uint64_t*)&cgen_var_1450, 1 * 8);
+    uint64_t cgen_var_1460;
+    stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1460, 1);
+    stream->write((uint64_t*)&cgen_var_1460, 1 * 8);
     stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_marker, sizeof(uint32_t));
     mImpl->log("finish vkCmdWriteBufferMarkerAMD");;
@@ -20846,12 +20976,12 @@
     }
     countingStream->rewind();
     {
-        uint64_t cgen_var_1451;
-        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1451, 1);
-        countingStream->write((uint64_t*)&cgen_var_1451, 1 * 8);
+        uint64_t cgen_var_1461;
+        countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1461, 1);
+        countingStream->write((uint64_t*)&cgen_var_1461, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1452 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
-        countingStream->putBe64(cgen_var_1452);
+        uint64_t cgen_var_1462 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
+        countingStream->putBe64(cgen_var_1462);
         if (local_pCheckpointMarker)
         {
             countingStream->write((void*)local_pCheckpointMarker, sizeof(uint8_t));
@@ -20862,12 +20992,12 @@
     uint32_t opcode_vkCmdSetCheckpointNV = OP_vkCmdSetCheckpointNV;
     stream->write(&opcode_vkCmdSetCheckpointNV, sizeof(uint32_t));
     stream->write(&packetSize_vkCmdSetCheckpointNV, sizeof(uint32_t));
-    uint64_t cgen_var_1453;
-    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1453, 1);
-    stream->write((uint64_t*)&cgen_var_1453, 1 * 8);
+    uint64_t cgen_var_1463;
+    stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1463, 1);
+    stream->write((uint64_t*)&cgen_var_1463, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1454 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
-    stream->putBe64(cgen_var_1454);
+    uint64_t cgen_var_1464 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
+    stream->putBe64(cgen_var_1464);
     if (local_pCheckpointMarker)
     {
         stream->write((void*)local_pCheckpointMarker, sizeof(uint8_t));
@@ -20890,19 +21020,19 @@
     local_queue = queue;
     countingStream->rewind();
     {
-        uint64_t cgen_var_1455;
-        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1455, 1);
-        countingStream->write((uint64_t*)&cgen_var_1455, 1 * 8);
+        uint64_t cgen_var_1465;
+        countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1465, 1);
+        countingStream->write((uint64_t*)&cgen_var_1465, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1456 = (uint64_t)(uintptr_t)pCheckpointDataCount;
-        countingStream->putBe64(cgen_var_1456);
+        uint64_t cgen_var_1466 = (uint64_t)(uintptr_t)pCheckpointDataCount;
+        countingStream->putBe64(cgen_var_1466);
         if (pCheckpointDataCount)
         {
             countingStream->write((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
         }
         // WARNING PTR CHECK
-        uint64_t cgen_var_1457 = (uint64_t)(uintptr_t)pCheckpointData;
-        countingStream->putBe64(cgen_var_1457);
+        uint64_t cgen_var_1467 = (uint64_t)(uintptr_t)pCheckpointData;
+        countingStream->putBe64(cgen_var_1467);
         if (pCheckpointData)
         {
             for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
@@ -20916,19 +21046,19 @@
     uint32_t opcode_vkGetQueueCheckpointDataNV = OP_vkGetQueueCheckpointDataNV;
     stream->write(&opcode_vkGetQueueCheckpointDataNV, sizeof(uint32_t));
     stream->write(&packetSize_vkGetQueueCheckpointDataNV, sizeof(uint32_t));
-    uint64_t cgen_var_1458;
-    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1458, 1);
-    stream->write((uint64_t*)&cgen_var_1458, 1 * 8);
+    uint64_t cgen_var_1468;
+    stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1468, 1);
+    stream->write((uint64_t*)&cgen_var_1468, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1459 = (uint64_t)(uintptr_t)pCheckpointDataCount;
-    stream->putBe64(cgen_var_1459);
+    uint64_t cgen_var_1469 = (uint64_t)(uintptr_t)pCheckpointDataCount;
+    stream->putBe64(cgen_var_1469);
     if (pCheckpointDataCount)
     {
         stream->write((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_1460 = (uint64_t)(uintptr_t)pCheckpointData;
-    stream->putBe64(cgen_var_1460);
+    uint64_t cgen_var_1470 = (uint64_t)(uintptr_t)pCheckpointData;
+    stream->putBe64(cgen_var_1470);
     if (pCheckpointData)
     {
         for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
@@ -20992,15 +21122,15 @@
     mImpl->resources()->deviceMemoryTransform_tohost(&local_memory, 1, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0);
     countingStream->rewind();
     {
-        uint64_t cgen_var_1463;
-        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1463, 1);
-        countingStream->write((uint64_t*)&cgen_var_1463, 1 * 8);
-        uint64_t cgen_var_1464;
-        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1464, 1);
-        countingStream->write((uint64_t*)&cgen_var_1464, 1 * 8);
+        uint64_t cgen_var_1473;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1473, 1);
+        countingStream->write((uint64_t*)&cgen_var_1473, 1 * 8);
+        uint64_t cgen_var_1474;
+        countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1474, 1);
+        countingStream->write((uint64_t*)&cgen_var_1474, 1 * 8);
         // WARNING PTR CHECK
-        uint64_t cgen_var_1465 = (uint64_t)(uintptr_t)pAddress;
-        countingStream->putBe64(cgen_var_1465);
+        uint64_t cgen_var_1475 = (uint64_t)(uintptr_t)pAddress;
+        countingStream->putBe64(cgen_var_1475);
         if (pAddress)
         {
             countingStream->write((uint64_t*)pAddress, sizeof(uint64_t));
@@ -21011,15 +21141,15 @@
     uint32_t opcode_vkMapMemoryIntoAddressSpaceGOOGLE = OP_vkMapMemoryIntoAddressSpaceGOOGLE;
     stream->write(&opcode_vkMapMemoryIntoAddressSpaceGOOGLE, sizeof(uint32_t));
     stream->write(&packetSize_vkMapMemoryIntoAddressSpaceGOOGLE, sizeof(uint32_t));
-    uint64_t cgen_var_1466;
-    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1466, 1);
-    stream->write((uint64_t*)&cgen_var_1466, 1 * 8);
-    uint64_t cgen_var_1467;
-    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1467, 1);
-    stream->write((uint64_t*)&cgen_var_1467, 1 * 8);
+    uint64_t cgen_var_1476;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1476, 1);
+    stream->write((uint64_t*)&cgen_var_1476, 1 * 8);
+    uint64_t cgen_var_1477;
+    stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1477, 1);
+    stream->write((uint64_t*)&cgen_var_1477, 1 * 8);
     // WARNING PTR CHECK
-    uint64_t cgen_var_1468 = (uint64_t)(uintptr_t)pAddress;
-    stream->putBe64(cgen_var_1468);
+    uint64_t cgen_var_1478 = (uint64_t)(uintptr_t)pAddress;
+    stream->putBe64(cgen_var_1478);
     if (pAddress)
     {
         stream->write((uint64_t*)pAddress, sizeof(uint64_t));
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
index 7c2bf8c..1ee8575 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -28,6 +28,7 @@
 #include "goldfish_vk_extension_structs_guest.h"
 #include "goldfish_vk_private_defs.h"
 
+#include <stdio.h>
 
 namespace goldfish_vk {
 
@@ -680,7 +681,9 @@
     to->pQueueFamilyIndices = nullptr;
     if (from->pQueueFamilyIndices)
     {
+        fprintf(stderr, "%s: begin qfi. count: %u\n", __func__, from->queueFamilyIndexCount);
         to->pQueueFamilyIndices = (uint32_t*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+        fprintf(stderr, "%s: end qfi\n", __func__);
     }
 }