diff --git a/host/vulkan/VkSubDecoder.cpp b/host/vulkan/VkSubDecoder.cpp
index c0abdf4..6f5f700 100644
--- a/host/vulkan/VkSubDecoder.cpp
+++ b/host/vulkan/VkSubDecoder.cpp
@@ -2038,16 +2038,162 @@
 #endif
 #ifdef VK_KHR_swapchain
 #endif
+#ifdef VK_KHR_display
+#endif
+#ifdef VK_KHR_display_swapchain
+#endif
+#ifdef VK_KHR_xlib_surface
+#endif
 #ifdef VK_KHR_xcb_surface
 #endif
+#ifdef VK_KHR_wayland_surface
+#endif
 #ifdef VK_KHR_android_surface
 #endif
 #ifdef VK_KHR_win32_surface
 #endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_video_queue
+            case OP_vkCmdBeginVideoCodingKHR: {
+                android::base::beginTrace("vkCmdBeginVideoCodingKHR subdecode");
+                const VkVideoBeginCodingInfoKHR* pBeginInfo;
+                VkVideoBeginCodingInfoKHR stack_pBeginInfo[1];
+                pBeginInfo = (VkVideoBeginCodingInfoKHR*)stack_pBeginInfo;
+                reservedunmarshal_VkVideoBeginCodingInfoKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkVideoBeginCodingInfoKHR*)(pBeginInfo), readStreamPtrPtr);
+                if (pBeginInfo) {
+                    transform_tohost_VkVideoBeginCodingInfoKHR(
+                        globalstate, (VkVideoBeginCodingInfoKHR*)(pBeginInfo));
+                }
+                vk->vkCmdBeginVideoCodingKHR((VkCommandBuffer)dispatchHandle, pBeginInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdEndVideoCodingKHR: {
+                android::base::beginTrace("vkCmdEndVideoCodingKHR subdecode");
+                const VkVideoEndCodingInfoKHR* pEndCodingInfo;
+                VkVideoEndCodingInfoKHR stack_pEndCodingInfo[1];
+                pEndCodingInfo = (VkVideoEndCodingInfoKHR*)stack_pEndCodingInfo;
+                reservedunmarshal_VkVideoEndCodingInfoKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkVideoEndCodingInfoKHR*)(pEndCodingInfo), readStreamPtrPtr);
+                if (pEndCodingInfo) {
+                    transform_tohost_VkVideoEndCodingInfoKHR(
+                        globalstate, (VkVideoEndCodingInfoKHR*)(pEndCodingInfo));
+                }
+                vk->vkCmdEndVideoCodingKHR((VkCommandBuffer)dispatchHandle, pEndCodingInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdControlVideoCodingKHR: {
+                android::base::beginTrace("vkCmdControlVideoCodingKHR subdecode");
+                const VkVideoCodingControlInfoKHR* pCodingControlInfo;
+                VkVideoCodingControlInfoKHR stack_pCodingControlInfo[1];
+                pCodingControlInfo = (VkVideoCodingControlInfoKHR*)stack_pCodingControlInfo;
+                reservedunmarshal_VkVideoCodingControlInfoKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkVideoCodingControlInfoKHR*)(pCodingControlInfo), readStreamPtrPtr);
+                if (pCodingControlInfo) {
+                    transform_tohost_VkVideoCodingControlInfoKHR(
+                        globalstate, (VkVideoCodingControlInfoKHR*)(pCodingControlInfo));
+                }
+                vk->vkCmdControlVideoCodingKHR((VkCommandBuffer)dispatchHandle, pCodingControlInfo);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_video_decode_queue
+            case OP_vkCmdDecodeVideoKHR: {
+                android::base::beginTrace("vkCmdDecodeVideoKHR subdecode");
+                const VkVideoDecodeInfoKHR* pDecodeInfo;
+                VkVideoDecodeInfoKHR stack_pDecodeInfo[1];
+                pDecodeInfo = (VkVideoDecodeInfoKHR*)stack_pDecodeInfo;
+                reservedunmarshal_VkVideoDecodeInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkVideoDecodeInfoKHR*)(pDecodeInfo),
+                                                       readStreamPtrPtr);
+                if (pDecodeInfo) {
+                    transform_tohost_VkVideoDecodeInfoKHR(globalstate,
+                                                          (VkVideoDecodeInfoKHR*)(pDecodeInfo));
+                }
+                vk->vkCmdDecodeVideoKHR((VkCommandBuffer)dispatchHandle, pDecodeInfo);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_video_decode_h264
+#endif
+#ifdef VK_KHR_dynamic_rendering
+            case OP_vkCmdBeginRenderingKHR: {
+                android::base::beginTrace("vkCmdBeginRenderingKHR subdecode");
+                const VkRenderingInfo* pRenderingInfo;
+                VkRenderingInfo stack_pRenderingInfo[1];
+                pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
+                reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                  (VkRenderingInfo*)(pRenderingInfo),
+                                                  readStreamPtrPtr);
+                if (pRenderingInfo) {
+                    transform_tohost_VkRenderingInfo(globalstate,
+                                                     (VkRenderingInfo*)(pRenderingInfo));
+                }
+                vk->vkCmdBeginRenderingKHR((VkCommandBuffer)dispatchHandle, pRenderingInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdEndRenderingKHR: {
+                android::base::beginTrace("vkCmdEndRenderingKHR subdecode");
+                vk->vkCmdEndRenderingKHR((VkCommandBuffer)dispatchHandle);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_multiview
+#endif
 #ifdef VK_KHR_get_physical_device_properties2
 #endif
+#ifdef VK_KHR_device_group
+            case OP_vkCmdSetDeviceMaskKHR: {
+                android::base::beginTrace("vkCmdSetDeviceMaskKHR subdecode");
+                uint32_t deviceMask;
+                memcpy((uint32_t*)&deviceMask, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdSetDeviceMaskKHR((VkCommandBuffer)dispatchHandle, deviceMask);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDispatchBaseKHR: {
+                android::base::beginTrace("vkCmdDispatchBaseKHR subdecode");
+                uint32_t baseGroupX;
+                uint32_t baseGroupY;
+                uint32_t baseGroupZ;
+                uint32_t groupCountX;
+                uint32_t groupCountY;
+                uint32_t groupCountZ;
+                memcpy((uint32_t*)&baseGroupX, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&baseGroupY, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&baseGroupZ, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDispatchBaseKHR((VkCommandBuffer)dispatchHandle, baseGroupX, baseGroupY,
+                                         baseGroupZ, groupCountX, groupCountY, groupCountZ);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
 #ifdef VK_KHR_maintenance1
 #endif
+#ifdef VK_KHR_device_group_creation
+#endif
 #ifdef VK_KHR_external_memory_capabilities
 #endif
 #ifdef VK_KHR_external_memory
@@ -2056,6 +2202,8 @@
 #endif
 #ifdef VK_KHR_external_memory_fd
 #endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
 #ifdef VK_KHR_external_semaphore_capabilities
 #endif
 #ifdef VK_KHR_external_semaphore
@@ -2064,8 +2212,89 @@
 #endif
 #ifdef VK_KHR_external_semaphore_fd
 #endif
+#ifdef VK_KHR_push_descriptor
+            case OP_vkCmdPushDescriptorSetKHR: {
+                android::base::beginTrace("vkCmdPushDescriptorSetKHR subdecode");
+                VkPipelineBindPoint pipelineBindPoint;
+                VkPipelineLayout layout;
+                uint32_t set;
+                uint32_t descriptorWriteCount;
+                const VkWriteDescriptorSet* pDescriptorWrites;
+                VkWriteDescriptorSet stack_pDescriptorWrites[MAX_STACK_ITEMS];
+                memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
+                       sizeof(VkPipelineBindPoint));
+                *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPipelineLayout*)&layout =
+                    (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
+                memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&descriptorWriteCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((descriptorWriteCount)) <= MAX_STACK_ITEMS) {
+                    pDescriptorWrites = (VkWriteDescriptorSet*)stack_pDescriptorWrites;
+                } else {
+                    readStream->alloc(
+                        (void**)&pDescriptorWrites,
+                        ((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+                    reservedunmarshal_VkWriteDescriptorSet(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkWriteDescriptorSet*)(pDescriptorWrites + i), readStreamPtrPtr);
+                }
+                if (pDescriptorWrites) {
+                    for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+                        transform_tohost_VkWriteDescriptorSet(
+                            globalstate, (VkWriteDescriptorSet*)(pDescriptorWrites + i));
+                    }
+                }
+                vk->vkCmdPushDescriptorSetKHR((VkCommandBuffer)dispatchHandle, pipelineBindPoint,
+                                              layout, set, descriptorWriteCount, pDescriptorWrites);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdPushDescriptorSetWithTemplateKHR: {
+                android::base::beginTrace("vkCmdPushDescriptorSetWithTemplateKHR subdecode");
+                VkDescriptorUpdateTemplate descriptorUpdateTemplate;
+                VkPipelineLayout layout;
+                uint32_t set;
+                const void* pData;
+                uint8_t* stack_pData[1];
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate =
+                    (VkDescriptorUpdateTemplate)unbox_VkDescriptorUpdateTemplate(
+                        (VkDescriptorUpdateTemplate)(*&cgen_var_0));
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPipelineLayout*)&layout =
+                    (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_1));
+                memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((void**)&pData, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pData);
+                *readStreamPtrPtr += 8;
+                if (pData) {
+                    pData = (void*)stack_pData;
+                    memcpy((void*)pData, *readStreamPtrPtr, sizeof(const uint8_t));
+                    *readStreamPtrPtr += sizeof(const uint8_t);
+                }
+                vk->vkCmdPushDescriptorSetWithTemplateKHR(
+                    (VkCommandBuffer)dispatchHandle, descriptorUpdateTemplate, layout, set, pData);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_KHR_shader_float16_int8
 #endif
+#ifdef VK_KHR_16bit_storage
+#endif
 #ifdef VK_KHR_incremental_present
 #endif
 #ifdef VK_KHR_descriptor_update_template
@@ -2144,18 +2373,32 @@
                 break;
             }
 #endif
+#ifdef VK_KHR_shared_presentable_image
+#endif
 #ifdef VK_KHR_external_fence_capabilities
 #endif
 #ifdef VK_KHR_external_fence
 #endif
+#ifdef VK_KHR_external_fence_win32
+#endif
 #ifdef VK_KHR_external_fence_fd
 #endif
+#ifdef VK_KHR_performance_query
+#endif
 #ifdef VK_KHR_maintenance2
 #endif
+#ifdef VK_KHR_get_surface_capabilities2
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+#endif
 #ifdef VK_KHR_dedicated_allocation
 #endif
 #ifdef VK_KHR_storage_buffer_storage_class
 #endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
 #ifdef VK_KHR_get_memory_requirements2
 #endif
 #ifdef VK_KHR_image_format_list
@@ -2164,20 +2407,492 @@
 #endif
 #ifdef VK_KHR_bind_memory2
 #endif
+#ifdef VK_KHR_portability_subset
+#endif
 #ifdef VK_KHR_maintenance3
 #endif
+#ifdef VK_KHR_draw_indirect_count
+            case OP_vkCmdDrawIndirectCountKHR: {
+                android::base::beginTrace("vkCmdDrawIndirectCountKHR subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                VkBuffer countBuffer;
+                VkDeviceSize countBufferOffset;
+                uint32_t maxDrawCount;
+                uint32_t stride;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawIndirectCountKHR((VkCommandBuffer)dispatchHandle, buffer, offset,
+                                              countBuffer, countBufferOffset, maxDrawCount, stride);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawIndexedIndirectCountKHR: {
+                android::base::beginTrace("vkCmdDrawIndexedIndirectCountKHR subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                VkBuffer countBuffer;
+                VkDeviceSize countBufferOffset;
+                uint32_t maxDrawCount;
+                uint32_t stride;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawIndexedIndirectCountKHR((VkCommandBuffer)dispatchHandle, buffer,
+                                                     offset, countBuffer, countBufferOffset,
+                                                     maxDrawCount, stride);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_KHR_shader_subgroup_extended_types
 #endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_KHR_shader_atomic_int64
+#endif
+#ifdef VK_KHR_shader_clock
+#endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
+#ifdef VK_KHR_driver_properties
+#endif
+#ifdef VK_KHR_shader_float_controls
+#endif
+#ifdef VK_KHR_depth_stencil_resolve
+#endif
+#ifdef VK_KHR_swapchain_mutable_format
+#endif
+#ifdef VK_KHR_timeline_semaphore
+#endif
 #ifdef VK_KHR_vulkan_memory_model
 #endif
 #ifdef VK_KHR_shader_terminate_invocation
 #endif
+#ifdef VK_KHR_fragment_shading_rate
+            case OP_vkCmdSetFragmentShadingRateKHR: {
+                android::base::beginTrace("vkCmdSetFragmentShadingRateKHR subdecode");
+                const VkExtent2D* pFragmentSize;
+                VkExtent2D stack_pFragmentSize[1];
+                VkFragmentShadingRateCombinerOpKHR combinerOps[2];
+                pFragmentSize = (VkExtent2D*)stack_pFragmentSize;
+                reservedunmarshal_VkExtent2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                             (VkExtent2D*)(pFragmentSize), readStreamPtrPtr);
+                memcpy((VkFragmentShadingRateCombinerOpKHR*)combinerOps, *readStreamPtrPtr,
+                       2 * sizeof(const VkFragmentShadingRateCombinerOpKHR));
+                *readStreamPtrPtr += 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR);
+                if (pFragmentSize) {
+                    transform_tohost_VkExtent2D(globalstate, (VkExtent2D*)(pFragmentSize));
+                }
+                vk->vkCmdSetFragmentShadingRateKHR((VkCommandBuffer)dispatchHandle, pFragmentSize,
+                                                   combinerOps);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_spirv_1_4
+#endif
+#ifdef VK_KHR_surface_protected_capabilities
+#endif
+#ifdef VK_KHR_separate_depth_stencil_layouts
+#endif
+#ifdef VK_KHR_present_wait
+#endif
+#ifdef VK_KHR_uniform_buffer_standard_layout
+#endif
 #ifdef VK_KHR_buffer_device_address
 #endif
+#ifdef VK_KHR_deferred_host_operations
+#endif
 #ifdef VK_KHR_pipeline_executable_properties
 #endif
+#ifdef VK_KHR_map_memory2
+#endif
+#ifdef VK_KHR_shader_integer_dot_product
+#endif
+#ifdef VK_KHR_pipeline_library
+#endif
+#ifdef VK_KHR_shader_non_semantic_info
+#endif
+#ifdef VK_KHR_present_id
+#endif
+#ifdef VK_KHR_video_encode_queue
+            case OP_vkCmdEncodeVideoKHR: {
+                android::base::beginTrace("vkCmdEncodeVideoKHR subdecode");
+                const VkVideoEncodeInfoKHR* pEncodeInfo;
+                VkVideoEncodeInfoKHR stack_pEncodeInfo[1];
+                pEncodeInfo = (VkVideoEncodeInfoKHR*)stack_pEncodeInfo;
+                reservedunmarshal_VkVideoEncodeInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkVideoEncodeInfoKHR*)(pEncodeInfo),
+                                                       readStreamPtrPtr);
+                if (pEncodeInfo) {
+                    transform_tohost_VkVideoEncodeInfoKHR(globalstate,
+                                                          (VkVideoEncodeInfoKHR*)(pEncodeInfo));
+                }
+                vk->vkCmdEncodeVideoKHR((VkCommandBuffer)dispatchHandle, pEncodeInfo);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_synchronization2
+            case OP_vkCmdSetEvent2KHR: {
+                android::base::beginTrace("vkCmdSetEvent2KHR subdecode");
+                VkEvent event;
+                const VkDependencyInfo* pDependencyInfo;
+                VkDependencyInfo stack_pDependencyInfo[1];
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
+                pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
+                reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkDependencyInfo*)(pDependencyInfo),
+                                                   readStreamPtrPtr);
+                if (pDependencyInfo) {
+                    transform_tohost_VkDependencyInfo(globalstate,
+                                                      (VkDependencyInfo*)(pDependencyInfo));
+                }
+                vk->vkCmdSetEvent2KHR((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdResetEvent2KHR: {
+                android::base::beginTrace("vkCmdResetEvent2KHR subdecode");
+                VkEvent event;
+                VkPipelineStageFlags2 stageMask;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
+                memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
+                vk->vkCmdResetEvent2KHR((VkCommandBuffer)dispatchHandle, event, stageMask);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWaitEvents2KHR: {
+                android::base::beginTrace("vkCmdWaitEvents2KHR subdecode");
+                uint32_t eventCount;
+                const VkEvent* pEvents;
+                VkEvent stack_pEvents[MAX_STACK_ITEMS];
+                const VkDependencyInfo* pDependencyInfos;
+                VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((eventCount)) <= MAX_STACK_ITEMS) {
+                    pEvents = (VkEvent*)stack_pEvents;
+                } else {
+                    readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
+                }
+                if (((eventCount))) {
+                    uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
+                    *readStreamPtrPtr += 8 * ((eventCount));
+                    for (uint32_t k = 0; k < ((eventCount)); ++k) {
+                        uint64_t tmpval;
+                        memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
+                        *(((VkEvent*)pEvents) + k) = (VkEvent)unbox_VkEvent((VkEvent)tmpval);
+                    }
+                }
+                if (((eventCount)) <= MAX_STACK_ITEMS) {
+                    pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
+                } else {
+                    readStream->alloc((void**)&pDependencyInfos,
+                                      ((eventCount)) * sizeof(const VkDependencyInfo));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+                    reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkDependencyInfo*)(pDependencyInfos + i),
+                                                       readStreamPtrPtr);
+                }
+                if (pDependencyInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+                        transform_tohost_VkDependencyInfo(
+                            globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
+                    }
+                }
+                vk->vkCmdWaitEvents2KHR((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
+                                        pDependencyInfos);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdPipelineBarrier2KHR: {
+                android::base::beginTrace("vkCmdPipelineBarrier2KHR subdecode");
+                const VkDependencyInfo* pDependencyInfo;
+                VkDependencyInfo stack_pDependencyInfo[1];
+                pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
+                reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkDependencyInfo*)(pDependencyInfo),
+                                                   readStreamPtrPtr);
+                if (pDependencyInfo) {
+                    transform_tohost_VkDependencyInfo(globalstate,
+                                                      (VkDependencyInfo*)(pDependencyInfo));
+                }
+                vk->vkCmdPipelineBarrier2KHR((VkCommandBuffer)dispatchHandle, pDependencyInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWriteTimestamp2KHR: {
+                android::base::beginTrace("vkCmdWriteTimestamp2KHR subdecode");
+                VkPipelineStageFlags2 stage;
+                VkQueryPool queryPool;
+                uint32_t query;
+                memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkQueryPool*)&queryPool =
+                    (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
+                memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdWriteTimestamp2KHR((VkCommandBuffer)dispatchHandle, stage, queryPool,
+                                            query);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWriteBufferMarker2AMD: {
+                android::base::beginTrace("vkCmdWriteBufferMarker2AMD subdecode");
+                VkPipelineStageFlags2 stage;
+                VkBuffer dstBuffer;
+                VkDeviceSize dstOffset;
+                uint32_t marker;
+                memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&marker, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdWriteBufferMarker2AMD((VkCommandBuffer)dispatchHandle, stage, dstBuffer,
+                                               dstOffset, marker);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
+#ifdef VK_KHR_shader_subgroup_uniform_control_flow
+#endif
+#ifdef VK_KHR_zero_initialize_workgroup_memory
+#endif
+#ifdef VK_KHR_workgroup_memory_explicit_layout
+#endif
+#ifdef VK_KHR_copy_commands2
+            case OP_vkCmdCopyBuffer2KHR: {
+                android::base::beginTrace("vkCmdCopyBuffer2KHR subdecode");
+                const VkCopyBufferInfo2* pCopyBufferInfo;
+                VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
+                pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
+                reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkCopyBufferInfo2*)(pCopyBufferInfo),
+                                                    readStreamPtrPtr);
+                if (pCopyBufferInfo) {
+                    transform_tohost_VkCopyBufferInfo2(globalstate,
+                                                       (VkCopyBufferInfo2*)(pCopyBufferInfo));
+                }
+                vk->vkCmdCopyBuffer2KHR((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyImage2KHR: {
+                android::base::beginTrace("vkCmdCopyImage2KHR subdecode");
+                const VkCopyImageInfo2* pCopyImageInfo;
+                VkCopyImageInfo2 stack_pCopyImageInfo[1];
+                pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
+                reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkCopyImageInfo2*)(pCopyImageInfo),
+                                                   readStreamPtrPtr);
+                if (pCopyImageInfo) {
+                    transform_tohost_VkCopyImageInfo2(globalstate,
+                                                      (VkCopyImageInfo2*)(pCopyImageInfo));
+                }
+                vk->vkCmdCopyImage2KHR((VkCommandBuffer)dispatchHandle, pCopyImageInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyBufferToImage2KHR: {
+                android::base::beginTrace("vkCmdCopyBufferToImage2KHR subdecode");
+                const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
+                VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
+                pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
+                reservedunmarshal_VkCopyBufferToImageInfo2(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
+                if (pCopyBufferToImageInfo) {
+                    transform_tohost_VkCopyBufferToImageInfo2(
+                        globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
+                }
+                vk->vkCmdCopyBufferToImage2KHR((VkCommandBuffer)dispatchHandle,
+                                               pCopyBufferToImageInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyImageToBuffer2KHR: {
+                android::base::beginTrace("vkCmdCopyImageToBuffer2KHR subdecode");
+                const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
+                VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
+                pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
+                reservedunmarshal_VkCopyImageToBufferInfo2(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
+                if (pCopyImageToBufferInfo) {
+                    transform_tohost_VkCopyImageToBufferInfo2(
+                        globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
+                }
+                vk->vkCmdCopyImageToBuffer2KHR((VkCommandBuffer)dispatchHandle,
+                                               pCopyImageToBufferInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBlitImage2KHR: {
+                android::base::beginTrace("vkCmdBlitImage2KHR subdecode");
+                const VkBlitImageInfo2* pBlitImageInfo;
+                VkBlitImageInfo2 stack_pBlitImageInfo[1];
+                pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
+                reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkBlitImageInfo2*)(pBlitImageInfo),
+                                                   readStreamPtrPtr);
+                if (pBlitImageInfo) {
+                    transform_tohost_VkBlitImageInfo2(globalstate,
+                                                      (VkBlitImageInfo2*)(pBlitImageInfo));
+                }
+                vk->vkCmdBlitImage2KHR((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdResolveImage2KHR: {
+                android::base::beginTrace("vkCmdResolveImage2KHR subdecode");
+                const VkResolveImageInfo2* pResolveImageInfo;
+                VkResolveImageInfo2 stack_pResolveImageInfo[1];
+                pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
+                reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                      (VkResolveImageInfo2*)(pResolveImageInfo),
+                                                      readStreamPtrPtr);
+                if (pResolveImageInfo) {
+                    transform_tohost_VkResolveImageInfo2(globalstate,
+                                                         (VkResolveImageInfo2*)(pResolveImageInfo));
+                }
+                vk->vkCmdResolveImage2KHR((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_format_feature_flags2
+#endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+            case OP_vkCmdTraceRaysIndirect2KHR: {
+                android::base::beginTrace("vkCmdTraceRaysIndirect2KHR subdecode");
+                VkDeviceAddress indirectDeviceAddress;
+                memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                vk->vkCmdTraceRaysIndirect2KHR((VkCommandBuffer)dispatchHandle,
+                                               indirectDeviceAddress);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
+#ifdef VK_KHR_maintenance4
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
+#ifdef VK_EXT_debug_report
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+            case OP_vkCmdDebugMarkerBeginEXT: {
+                android::base::beginTrace("vkCmdDebugMarkerBeginEXT subdecode");
+                const VkDebugMarkerMarkerInfoEXT* pMarkerInfo;
+                VkDebugMarkerMarkerInfoEXT stack_pMarkerInfo[1];
+                pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)stack_pMarkerInfo;
+                reservedunmarshal_VkDebugMarkerMarkerInfoEXT(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo), readStreamPtrPtr);
+                if (pMarkerInfo) {
+                    transform_tohost_VkDebugMarkerMarkerInfoEXT(
+                        globalstate, (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo));
+                }
+                vk->vkCmdDebugMarkerBeginEXT((VkCommandBuffer)dispatchHandle, pMarkerInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDebugMarkerEndEXT: {
+                android::base::beginTrace("vkCmdDebugMarkerEndEXT subdecode");
+                vk->vkCmdDebugMarkerEndEXT((VkCommandBuffer)dispatchHandle);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDebugMarkerInsertEXT: {
+                android::base::beginTrace("vkCmdDebugMarkerInsertEXT subdecode");
+                const VkDebugMarkerMarkerInfoEXT* pMarkerInfo;
+                VkDebugMarkerMarkerInfoEXT stack_pMarkerInfo[1];
+                pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)stack_pMarkerInfo;
+                reservedunmarshal_VkDebugMarkerMarkerInfoEXT(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo), readStreamPtrPtr);
+                if (pMarkerInfo) {
+                    transform_tohost_VkDebugMarkerMarkerInfoEXT(
+                        globalstate, (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo));
+                }
+                vk->vkCmdDebugMarkerInsertEXT((VkCommandBuffer)dispatchHandle, pMarkerInfo);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
 #ifdef VK_EXT_transform_feedback
             case OP_vkCmdBindTransformFeedbackBuffersEXT: {
                 android::base::beginTrace("vkCmdBindTransformFeedbackBuffersEXT subdecode");
@@ -2419,26 +3134,980 @@
                 break;
             }
 #endif
+#ifdef VK_NVX_binary_import
+            case OP_vkCmdCuLaunchKernelNVX: {
+                android::base::beginTrace("vkCmdCuLaunchKernelNVX subdecode");
+                const VkCuLaunchInfoNVX* pLaunchInfo;
+                VkCuLaunchInfoNVX stack_pLaunchInfo[1];
+                pLaunchInfo = (VkCuLaunchInfoNVX*)stack_pLaunchInfo;
+                reservedunmarshal_VkCuLaunchInfoNVX(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkCuLaunchInfoNVX*)(pLaunchInfo),
+                                                    readStreamPtrPtr);
+                if (pLaunchInfo) {
+                    transform_tohost_VkCuLaunchInfoNVX(globalstate,
+                                                       (VkCuLaunchInfoNVX*)(pLaunchInfo));
+                }
+                vk->vkCmdCuLaunchKernelNVX((VkCommandBuffer)dispatchHandle, pLaunchInfo);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NVX_image_view_handle
+#endif
+#ifdef VK_AMD_draw_indirect_count
+            case OP_vkCmdDrawIndirectCountAMD: {
+                android::base::beginTrace("vkCmdDrawIndirectCountAMD subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                VkBuffer countBuffer;
+                VkDeviceSize countBufferOffset;
+                uint32_t maxDrawCount;
+                uint32_t stride;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawIndirectCountAMD((VkCommandBuffer)dispatchHandle, buffer, offset,
+                                              countBuffer, countBufferOffset, maxDrawCount, stride);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawIndexedIndirectCountAMD: {
+                android::base::beginTrace("vkCmdDrawIndexedIndirectCountAMD subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                VkBuffer countBuffer;
+                VkDeviceSize countBufferOffset;
+                uint32_t maxDrawCount;
+                uint32_t stride;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawIndexedIndirectCountAMD((VkCommandBuffer)dispatchHandle, buffer,
+                                                     offset, countBuffer, countBufferOffset,
+                                                     maxDrawCount, stride);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
 #ifdef VK_AMD_gpu_shader_half_float
 #endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_EXT_video_encode_h264
+#endif
+#ifdef VK_EXT_video_encode_h265
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_GGP_stream_descriptor_surface
+#endif
+#ifdef VK_NV_corner_sampled_image
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_texture_compression_astc_hdr
+#endif
+#ifdef VK_EXT_astc_decode_mode
+#endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
+#ifdef VK_EXT_conditional_rendering
+            case OP_vkCmdBeginConditionalRenderingEXT: {
+                android::base::beginTrace("vkCmdBeginConditionalRenderingEXT subdecode");
+                const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin;
+                VkConditionalRenderingBeginInfoEXT stack_pConditionalRenderingBegin[1];
+                pConditionalRenderingBegin =
+                    (VkConditionalRenderingBeginInfoEXT*)stack_pConditionalRenderingBegin;
+                reservedunmarshal_VkConditionalRenderingBeginInfoEXT(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkConditionalRenderingBeginInfoEXT*)(pConditionalRenderingBegin),
+                    readStreamPtrPtr);
+                if (pConditionalRenderingBegin) {
+                    transform_tohost_VkConditionalRenderingBeginInfoEXT(
+                        globalstate,
+                        (VkConditionalRenderingBeginInfoEXT*)(pConditionalRenderingBegin));
+                }
+                vk->vkCmdBeginConditionalRenderingEXT((VkCommandBuffer)dispatchHandle,
+                                                      pConditionalRenderingBegin);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdEndConditionalRenderingEXT: {
+                android::base::beginTrace("vkCmdEndConditionalRenderingEXT subdecode");
+                vk->vkCmdEndConditionalRenderingEXT((VkCommandBuffer)dispatchHandle);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+            case OP_vkCmdSetViewportWScalingNV: {
+                android::base::beginTrace("vkCmdSetViewportWScalingNV subdecode");
+                uint32_t firstViewport;
+                uint32_t viewportCount;
+                const VkViewportWScalingNV* pViewportWScalings;
+                VkViewportWScalingNV stack_pViewportWScalings[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((viewportCount)) <= MAX_STACK_ITEMS) {
+                    pViewportWScalings = (VkViewportWScalingNV*)stack_pViewportWScalings;
+                } else {
+                    readStream->alloc((void**)&pViewportWScalings,
+                                      ((viewportCount)) * sizeof(const VkViewportWScalingNV));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                    reservedunmarshal_VkViewportWScalingNV(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkViewportWScalingNV*)(pViewportWScalings + i), readStreamPtrPtr);
+                }
+                if (pViewportWScalings) {
+                    for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                        transform_tohost_VkViewportWScalingNV(
+                            globalstate, (VkViewportWScalingNV*)(pViewportWScalings + i));
+                    }
+                }
+                vk->vkCmdSetViewportWScalingNV((VkCommandBuffer)dispatchHandle, firstViewport,
+                                               viewportCount, pViewportWScalings);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+#endif
+#ifdef VK_EXT_display_control
+#endif
+#ifdef VK_GOOGLE_display_timing
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+            case OP_vkCmdSetDiscardRectangleEXT: {
+                android::base::beginTrace("vkCmdSetDiscardRectangleEXT subdecode");
+                uint32_t firstDiscardRectangle;
+                uint32_t discardRectangleCount;
+                const VkRect2D* pDiscardRectangles;
+                VkRect2D stack_pDiscardRectangles[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstDiscardRectangle, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&discardRectangleCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((discardRectangleCount)) <= MAX_STACK_ITEMS) {
+                    pDiscardRectangles = (VkRect2D*)stack_pDiscardRectangles;
+                } else {
+                    readStream->alloc((void**)&pDiscardRectangles,
+                                      ((discardRectangleCount)) * sizeof(const VkRect2D));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i) {
+                    reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                               (VkRect2D*)(pDiscardRectangles + i),
+                                               readStreamPtrPtr);
+                }
+                if (pDiscardRectangles) {
+                    for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i) {
+                        transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pDiscardRectangles + i));
+                    }
+                }
+                vk->vkCmdSetDiscardRectangleEXT((VkCommandBuffer)dispatchHandle,
+                                                firstDiscardRectangle, discardRectangleCount,
+                                                pDiscardRectangles);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDiscardRectangleEnableEXT: {
+                android::base::beginTrace("vkCmdSetDiscardRectangleEnableEXT subdecode");
+                VkBool32 discardRectangleEnable;
+                memcpy((VkBool32*)&discardRectangleEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDiscardRectangleEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                      discardRectangleEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDiscardRectangleModeEXT: {
+                android::base::beginTrace("vkCmdSetDiscardRectangleModeEXT subdecode");
+                VkDiscardRectangleModeEXT discardRectangleMode;
+                memcpy((VkDiscardRectangleModeEXT*)&discardRectangleMode, *readStreamPtrPtr,
+                       sizeof(VkDiscardRectangleModeEXT));
+                *readStreamPtrPtr += sizeof(VkDiscardRectangleModeEXT);
+                vk->vkCmdSetDiscardRectangleModeEXT((VkCommandBuffer)dispatchHandle,
+                                                    discardRectangleMode);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
+#ifdef VK_EXT_hdr_metadata
+#endif
+#ifdef VK_MVK_ios_surface
+#endif
+#ifdef VK_MVK_macos_surface
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
 #ifdef VK_EXT_queue_family_foreign
 #endif
 #ifdef VK_EXT_debug_utils
+            case OP_vkCmdBeginDebugUtilsLabelEXT: {
+                android::base::beginTrace("vkCmdBeginDebugUtilsLabelEXT subdecode");
+                const VkDebugUtilsLabelEXT* pLabelInfo;
+                VkDebugUtilsLabelEXT stack_pLabelInfo[1];
+                pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
+                reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkDebugUtilsLabelEXT*)(pLabelInfo),
+                                                       readStreamPtrPtr);
+                if (pLabelInfo) {
+                    transform_tohost_VkDebugUtilsLabelEXT(globalstate,
+                                                          (VkDebugUtilsLabelEXT*)(pLabelInfo));
+                }
+                vk->vkCmdBeginDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdEndDebugUtilsLabelEXT: {
+                android::base::beginTrace("vkCmdEndDebugUtilsLabelEXT subdecode");
+                vk->vkCmdEndDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdInsertDebugUtilsLabelEXT: {
+                android::base::beginTrace("vkCmdInsertDebugUtilsLabelEXT subdecode");
+                const VkDebugUtilsLabelEXT* pLabelInfo;
+                VkDebugUtilsLabelEXT stack_pLabelInfo[1];
+                pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
+                reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkDebugUtilsLabelEXT*)(pLabelInfo),
+                                                       readStreamPtrPtr);
+                if (pLabelInfo) {
+                    transform_tohost_VkDebugUtilsLabelEXT(globalstate,
+                                                          (VkDebugUtilsLabelEXT*)(pLabelInfo));
+                }
+                vk->vkCmdInsertDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
+                android::base::endTrace();
+                break;
+            }
 #endif
 #ifdef VK_ANDROID_external_memory_android_hardware_buffer
 #endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_inline_uniform_block
+#endif
 #ifdef VK_EXT_shader_stencil_export
 #endif
+#ifdef VK_EXT_sample_locations
+            case OP_vkCmdSetSampleLocationsEXT: {
+                android::base::beginTrace("vkCmdSetSampleLocationsEXT subdecode");
+                const VkSampleLocationsInfoEXT* pSampleLocationsInfo;
+                VkSampleLocationsInfoEXT stack_pSampleLocationsInfo[1];
+                pSampleLocationsInfo = (VkSampleLocationsInfoEXT*)stack_pSampleLocationsInfo;
+                reservedunmarshal_VkSampleLocationsInfoEXT(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkSampleLocationsInfoEXT*)(pSampleLocationsInfo), readStreamPtrPtr);
+                if (pSampleLocationsInfo) {
+                    transform_tohost_VkSampleLocationsInfoEXT(
+                        globalstate, (VkSampleLocationsInfoEXT*)(pSampleLocationsInfo));
+                }
+                vk->vkCmdSetSampleLocationsEXT((VkCommandBuffer)dispatchHandle,
+                                               pSampleLocationsInfo);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_NV_shader_sm_builtins
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_image_drm_format_modifier
+#endif
+#ifdef VK_EXT_validation_cache
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_NV_shading_rate_image
+            case OP_vkCmdBindShadingRateImageNV: {
+                android::base::beginTrace("vkCmdBindShadingRateImageNV subdecode");
+                VkImageView imageView;
+                VkImageLayout imageLayout;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkImageView*)&imageView =
+                    (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_0));
+                memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
+                *readStreamPtrPtr += sizeof(VkImageLayout);
+                vk->vkCmdBindShadingRateImageNV((VkCommandBuffer)dispatchHandle, imageView,
+                                                imageLayout);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetViewportShadingRatePaletteNV: {
+                android::base::beginTrace("vkCmdSetViewportShadingRatePaletteNV subdecode");
+                uint32_t firstViewport;
+                uint32_t viewportCount;
+                const VkShadingRatePaletteNV* pShadingRatePalettes;
+                VkShadingRatePaletteNV stack_pShadingRatePalettes[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((viewportCount)) <= MAX_STACK_ITEMS) {
+                    pShadingRatePalettes = (VkShadingRatePaletteNV*)stack_pShadingRatePalettes;
+                } else {
+                    readStream->alloc((void**)&pShadingRatePalettes,
+                                      ((viewportCount)) * sizeof(const VkShadingRatePaletteNV));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                    reservedunmarshal_VkShadingRatePaletteNV(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkShadingRatePaletteNV*)(pShadingRatePalettes + i), readStreamPtrPtr);
+                }
+                if (pShadingRatePalettes) {
+                    for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                        transform_tohost_VkShadingRatePaletteNV(
+                            globalstate, (VkShadingRatePaletteNV*)(pShadingRatePalettes + i));
+                    }
+                }
+                vk->vkCmdSetViewportShadingRatePaletteNV((VkCommandBuffer)dispatchHandle,
+                                                         firstViewport, viewportCount,
+                                                         pShadingRatePalettes);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoarseSampleOrderNV: {
+                android::base::beginTrace("vkCmdSetCoarseSampleOrderNV subdecode");
+                VkCoarseSampleOrderTypeNV sampleOrderType;
+                uint32_t customSampleOrderCount;
+                const VkCoarseSampleOrderCustomNV* pCustomSampleOrders;
+                VkCoarseSampleOrderCustomNV stack_pCustomSampleOrders[MAX_STACK_ITEMS];
+                memcpy((VkCoarseSampleOrderTypeNV*)&sampleOrderType, *readStreamPtrPtr,
+                       sizeof(VkCoarseSampleOrderTypeNV));
+                *readStreamPtrPtr += sizeof(VkCoarseSampleOrderTypeNV);
+                memcpy((uint32_t*)&customSampleOrderCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((customSampleOrderCount)) <= MAX_STACK_ITEMS) {
+                    pCustomSampleOrders = (VkCoarseSampleOrderCustomNV*)stack_pCustomSampleOrders;
+                } else {
+                    readStream->alloc(
+                        (void**)&pCustomSampleOrders,
+                        ((customSampleOrderCount)) * sizeof(const VkCoarseSampleOrderCustomNV));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i) {
+                    reservedunmarshal_VkCoarseSampleOrderCustomNV(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkCoarseSampleOrderCustomNV*)(pCustomSampleOrders + i), readStreamPtrPtr);
+                }
+                if (pCustomSampleOrders) {
+                    for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i) {
+                        transform_tohost_VkCoarseSampleOrderCustomNV(
+                            globalstate, (VkCoarseSampleOrderCustomNV*)(pCustomSampleOrders + i));
+                    }
+                }
+                vk->vkCmdSetCoarseSampleOrderNV((VkCommandBuffer)dispatchHandle, sampleOrderType,
+                                                customSampleOrderCount, pCustomSampleOrders);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_ray_tracing
+            case OP_vkCmdBuildAccelerationStructureNV: {
+                android::base::beginTrace("vkCmdBuildAccelerationStructureNV subdecode");
+                const VkAccelerationStructureInfoNV* pInfo;
+                VkAccelerationStructureInfoNV stack_pInfo[1];
+                VkBuffer instanceData;
+                VkDeviceSize instanceOffset;
+                VkBool32 update;
+                VkAccelerationStructureNV dst;
+                VkAccelerationStructureNV src;
+                VkBuffer scratch;
+                VkDeviceSize scratchOffset;
+                pInfo = (VkAccelerationStructureInfoNV*)stack_pInfo;
+                reservedunmarshal_VkAccelerationStructureInfoNV(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureInfoNV*)(pInfo),
+                    readStreamPtrPtr);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&instanceData = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&instanceOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((VkBool32*)&update, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkAccelerationStructureNV*)&dst =
+                    (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
+                        (VkAccelerationStructureNV)(*&cgen_var_1));
+                uint64_t cgen_var_2;
+                memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkAccelerationStructureNV*)&src =
+                    (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
+                        (VkAccelerationStructureNV)(*&cgen_var_2));
+                uint64_t cgen_var_3;
+                memcpy((uint64_t*)&cgen_var_3, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&scratch = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_3));
+                memcpy((VkDeviceSize*)&scratchOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                if (pInfo) {
+                    transform_tohost_VkAccelerationStructureInfoNV(
+                        globalstate, (VkAccelerationStructureInfoNV*)(pInfo));
+                }
+                vk->vkCmdBuildAccelerationStructureNV((VkCommandBuffer)dispatchHandle, pInfo,
+                                                      instanceData, instanceOffset, update, dst,
+                                                      src, scratch, scratchOffset);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyAccelerationStructureNV: {
+                android::base::beginTrace("vkCmdCopyAccelerationStructureNV subdecode");
+                VkAccelerationStructureNV dst;
+                VkAccelerationStructureNV src;
+                VkCopyAccelerationStructureModeKHR mode;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkAccelerationStructureNV*)&dst =
+                    (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
+                        (VkAccelerationStructureNV)(*&cgen_var_0));
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkAccelerationStructureNV*)&src =
+                    (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
+                        (VkAccelerationStructureNV)(*&cgen_var_1));
+                memcpy((VkCopyAccelerationStructureModeKHR*)&mode, *readStreamPtrPtr,
+                       sizeof(VkCopyAccelerationStructureModeKHR));
+                *readStreamPtrPtr += sizeof(VkCopyAccelerationStructureModeKHR);
+                vk->vkCmdCopyAccelerationStructureNV((VkCommandBuffer)dispatchHandle, dst, src,
+                                                     mode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdTraceRaysNV: {
+                android::base::beginTrace("vkCmdTraceRaysNV subdecode");
+                VkBuffer raygenShaderBindingTableBuffer;
+                VkDeviceSize raygenShaderBindingOffset;
+                VkBuffer missShaderBindingTableBuffer;
+                VkDeviceSize missShaderBindingOffset;
+                VkDeviceSize missShaderBindingStride;
+                VkBuffer hitShaderBindingTableBuffer;
+                VkDeviceSize hitShaderBindingOffset;
+                VkDeviceSize hitShaderBindingStride;
+                VkBuffer callableShaderBindingTableBuffer;
+                VkDeviceSize callableShaderBindingOffset;
+                VkDeviceSize callableShaderBindingStride;
+                uint32_t width;
+                uint32_t height;
+                uint32_t depth;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&raygenShaderBindingTableBuffer =
+                    (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&raygenShaderBindingOffset, *readStreamPtrPtr,
+                       sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&missShaderBindingTableBuffer =
+                    (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&missShaderBindingOffset, *readStreamPtrPtr,
+                       sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((VkDeviceSize*)&missShaderBindingStride, *readStreamPtrPtr,
+                       sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_2;
+                memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&hitShaderBindingTableBuffer =
+                    (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_2));
+                memcpy((VkDeviceSize*)&hitShaderBindingOffset, *readStreamPtrPtr,
+                       sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((VkDeviceSize*)&hitShaderBindingStride, *readStreamPtrPtr,
+                       sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_3;
+                memcpy((uint64_t*)&cgen_var_3, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&callableShaderBindingTableBuffer =
+                    (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_3));
+                memcpy((VkDeviceSize*)&callableShaderBindingOffset, *readStreamPtrPtr,
+                       sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((VkDeviceSize*)&callableShaderBindingStride, *readStreamPtrPtr,
+                       sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdTraceRaysNV((VkCommandBuffer)dispatchHandle,
+                                     raygenShaderBindingTableBuffer, raygenShaderBindingOffset,
+                                     missShaderBindingTableBuffer, missShaderBindingOffset,
+                                     missShaderBindingStride, hitShaderBindingTableBuffer,
+                                     hitShaderBindingOffset, hitShaderBindingStride,
+                                     callableShaderBindingTableBuffer, callableShaderBindingOffset,
+                                     callableShaderBindingStride, width, height, depth);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWriteAccelerationStructuresPropertiesNV: {
+                android::base::beginTrace("vkCmdWriteAccelerationStructuresPropertiesNV subdecode");
+                uint32_t accelerationStructureCount;
+                const VkAccelerationStructureNV* pAccelerationStructures;
+                VkAccelerationStructureNV stack_pAccelerationStructures[MAX_STACK_ITEMS];
+                VkQueryType queryType;
+                VkQueryPool queryPool;
+                uint32_t firstQuery;
+                memcpy((uint32_t*)&accelerationStructureCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((accelerationStructureCount)) <= MAX_STACK_ITEMS) {
+                    pAccelerationStructures =
+                        (VkAccelerationStructureNV*)stack_pAccelerationStructures;
+                } else {
+                    readStream->alloc(
+                        (void**)&pAccelerationStructures,
+                        ((accelerationStructureCount)) * sizeof(const VkAccelerationStructureNV));
+                }
+                if (((accelerationStructureCount))) {
+                    uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
+                    *readStreamPtrPtr += 8 * ((accelerationStructureCount));
+                    for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k) {
+                        uint64_t tmpval;
+                        memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
+                        *(((VkAccelerationStructureNV*)pAccelerationStructures) + k) =
+                            (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
+                                (VkAccelerationStructureNV)tmpval);
+                    }
+                }
+                memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
+                *readStreamPtrPtr += sizeof(VkQueryType);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkQueryPool*)&queryPool =
+                    (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
+                memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdWriteAccelerationStructuresPropertiesNV(
+                    (VkCommandBuffer)dispatchHandle, accelerationStructureCount,
+                    pAccelerationStructures, queryType, queryPool, firstQuery);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_representative_fragment_test
+#endif
+#ifdef VK_EXT_filter_cubic
+#endif
+#ifdef VK_QCOM_render_pass_shader_resolve
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+#endif
+#ifdef VK_AMD_buffer_marker
+            case OP_vkCmdWriteBufferMarkerAMD: {
+                android::base::beginTrace("vkCmdWriteBufferMarkerAMD subdecode");
+                VkPipelineStageFlagBits pipelineStage;
+                VkBuffer dstBuffer;
+                VkDeviceSize dstOffset;
+                uint32_t marker;
+                memcpy((VkPipelineStageFlagBits*)&pipelineStage, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlagBits));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlagBits);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&marker, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdWriteBufferMarkerAMD((VkCommandBuffer)dispatchHandle, pipelineStage,
+                                              dstBuffer, dstOffset, marker);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_AMD_pipeline_compiler_control
+#endif
+#ifdef VK_EXT_calibrated_timestamps
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_AMD_memory_overallocation_behavior
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_GGP_frame_token
+#endif
+#ifdef VK_EXT_pipeline_creation_feedback
+#endif
 #ifdef VK_NV_shader_subgroup_partitioned
 #endif
+#ifdef VK_NV_compute_shader_derivatives
+#endif
+#ifdef VK_NV_mesh_shader
+            case OP_vkCmdDrawMeshTasksNV: {
+                android::base::beginTrace("vkCmdDrawMeshTasksNV subdecode");
+                uint32_t taskCount;
+                uint32_t firstTask;
+                memcpy((uint32_t*)&taskCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&firstTask, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawMeshTasksNV((VkCommandBuffer)dispatchHandle, taskCount, firstTask);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawMeshTasksIndirectNV: {
+                android::base::beginTrace("vkCmdDrawMeshTasksIndirectNV subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                uint32_t drawCount;
+                uint32_t stride;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawMeshTasksIndirectNV((VkCommandBuffer)dispatchHandle, buffer, offset,
+                                                 drawCount, stride);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawMeshTasksIndirectCountNV: {
+                android::base::beginTrace("vkCmdDrawMeshTasksIndirectCountNV subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                VkBuffer countBuffer;
+                VkDeviceSize countBufferOffset;
+                uint32_t maxDrawCount;
+                uint32_t stride;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawMeshTasksIndirectCountNV((VkCommandBuffer)dispatchHandle, buffer,
+                                                      offset, countBuffer, countBufferOffset,
+                                                      maxDrawCount, stride);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_fragment_shader_barycentric
+#endif
+#ifdef VK_NV_shader_image_footprint
+#endif
+#ifdef VK_NV_scissor_exclusive
+            case OP_vkCmdSetExclusiveScissorEnableNV: {
+                android::base::beginTrace("vkCmdSetExclusiveScissorEnableNV subdecode");
+                uint32_t firstExclusiveScissor;
+                uint32_t exclusiveScissorCount;
+                const VkBool32* pExclusiveScissorEnables;
+                VkBool32 stack_pExclusiveScissorEnables[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstExclusiveScissor, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&exclusiveScissorCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((exclusiveScissorCount)) <= MAX_STACK_ITEMS) {
+                    pExclusiveScissorEnables = (VkBool32*)stack_pExclusiveScissorEnables;
+                } else {
+                    readStream->alloc((void**)&pExclusiveScissorEnables,
+                                      ((exclusiveScissorCount)) * sizeof(const VkBool32));
+                }
+                memcpy((VkBool32*)pExclusiveScissorEnables, *readStreamPtrPtr,
+                       ((exclusiveScissorCount)) * sizeof(const VkBool32));
+                *readStreamPtrPtr += ((exclusiveScissorCount)) * sizeof(const VkBool32);
+                vk->vkCmdSetExclusiveScissorEnableNV((VkCommandBuffer)dispatchHandle,
+                                                     firstExclusiveScissor, exclusiveScissorCount,
+                                                     pExclusiveScissorEnables);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetExclusiveScissorNV: {
+                android::base::beginTrace("vkCmdSetExclusiveScissorNV subdecode");
+                uint32_t firstExclusiveScissor;
+                uint32_t exclusiveScissorCount;
+                const VkRect2D* pExclusiveScissors;
+                VkRect2D stack_pExclusiveScissors[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstExclusiveScissor, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&exclusiveScissorCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((exclusiveScissorCount)) <= MAX_STACK_ITEMS) {
+                    pExclusiveScissors = (VkRect2D*)stack_pExclusiveScissors;
+                } else {
+                    readStream->alloc((void**)&pExclusiveScissors,
+                                      ((exclusiveScissorCount)) * sizeof(const VkRect2D));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i) {
+                    reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                               (VkRect2D*)(pExclusiveScissors + i),
+                                               readStreamPtrPtr);
+                }
+                if (pExclusiveScissors) {
+                    for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i) {
+                        transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pExclusiveScissors + i));
+                    }
+                }
+                vk->vkCmdSetExclusiveScissorNV((VkCommandBuffer)dispatchHandle,
+                                               firstExclusiveScissor, exclusiveScissorCount,
+                                               pExclusiveScissors);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+            case OP_vkCmdSetCheckpointNV: {
+                android::base::beginTrace("vkCmdSetCheckpointNV subdecode");
+                const void* pCheckpointMarker;
+                uint8_t* stack_pCheckpointMarker[1];
+                // WARNING PTR CHECK
+                memcpy((void**)&pCheckpointMarker, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pCheckpointMarker);
+                *readStreamPtrPtr += 8;
+                if (pCheckpointMarker) {
+                    pCheckpointMarker = (void*)stack_pCheckpointMarker;
+                    memcpy((void*)pCheckpointMarker, *readStreamPtrPtr, sizeof(const uint8_t));
+                    *readStreamPtrPtr += sizeof(const uint8_t);
+                }
+                vk->vkCmdSetCheckpointNV((VkCommandBuffer)dispatchHandle, pCheckpointMarker);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_INTEL_shader_integer_functions2
+#endif
+#ifdef VK_INTEL_performance_query
+            case OP_vkCmdSetPerformanceMarkerINTEL: {
+                android::base::beginTrace("vkCmdSetPerformanceMarkerINTEL subdecode");
+                const VkPerformanceMarkerInfoINTEL* pMarkerInfo;
+                VkPerformanceMarkerInfoINTEL stack_pMarkerInfo[1];
+                pMarkerInfo = (VkPerformanceMarkerInfoINTEL*)stack_pMarkerInfo;
+                reservedunmarshal_VkPerformanceMarkerInfoINTEL(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkPerformanceMarkerInfoINTEL*)(pMarkerInfo), readStreamPtrPtr);
+                if (pMarkerInfo) {
+                    transform_tohost_VkPerformanceMarkerInfoINTEL(
+                        globalstate, (VkPerformanceMarkerInfoINTEL*)(pMarkerInfo));
+                }
+                VkResult vkCmdSetPerformanceMarkerINTEL_VkResult_return = (VkResult)0;
+                vkCmdSetPerformanceMarkerINTEL_VkResult_return = vk->vkCmdSetPerformanceMarkerINTEL(
+                    (VkCommandBuffer)dispatchHandle, pMarkerInfo);
+                if ((vkCmdSetPerformanceMarkerINTEL_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    this->on_DeviceLost();
+                this->on_CheckOutOfMemory(vkCmdSetPerformanceMarkerINTEL_VkResult_return, opcode,
+                                          context);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPerformanceStreamMarkerINTEL: {
+                android::base::beginTrace("vkCmdSetPerformanceStreamMarkerINTEL subdecode");
+                const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo;
+                VkPerformanceStreamMarkerInfoINTEL stack_pMarkerInfo[1];
+                pMarkerInfo = (VkPerformanceStreamMarkerInfoINTEL*)stack_pMarkerInfo;
+                reservedunmarshal_VkPerformanceStreamMarkerInfoINTEL(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkPerformanceStreamMarkerInfoINTEL*)(pMarkerInfo), readStreamPtrPtr);
+                if (pMarkerInfo) {
+                    transform_tohost_VkPerformanceStreamMarkerInfoINTEL(
+                        globalstate, (VkPerformanceStreamMarkerInfoINTEL*)(pMarkerInfo));
+                }
+                VkResult vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return = (VkResult)0;
+                vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return =
+                    vk->vkCmdSetPerformanceStreamMarkerINTEL((VkCommandBuffer)dispatchHandle,
+                                                             pMarkerInfo);
+                if ((vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    this->on_DeviceLost();
+                this->on_CheckOutOfMemory(vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return,
+                                          opcode, context);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPerformanceOverrideINTEL: {
+                android::base::beginTrace("vkCmdSetPerformanceOverrideINTEL subdecode");
+                const VkPerformanceOverrideInfoINTEL* pOverrideInfo;
+                VkPerformanceOverrideInfoINTEL stack_pOverrideInfo[1];
+                pOverrideInfo = (VkPerformanceOverrideInfoINTEL*)stack_pOverrideInfo;
+                reservedunmarshal_VkPerformanceOverrideInfoINTEL(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkPerformanceOverrideInfoINTEL*)(pOverrideInfo), readStreamPtrPtr);
+                if (pOverrideInfo) {
+                    transform_tohost_VkPerformanceOverrideInfoINTEL(
+                        globalstate, (VkPerformanceOverrideInfoINTEL*)(pOverrideInfo));
+                }
+                VkResult vkCmdSetPerformanceOverrideINTEL_VkResult_return = (VkResult)0;
+                vkCmdSetPerformanceOverrideINTEL_VkResult_return =
+                    vk->vkCmdSetPerformanceOverrideINTEL((VkCommandBuffer)dispatchHandle,
+                                                         pOverrideInfo);
+                if ((vkCmdSetPerformanceOverrideINTEL_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    this->on_DeviceLost();
+                this->on_CheckOutOfMemory(vkCmdSetPerformanceOverrideINTEL_VkResult_return, opcode,
+                                          context);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_pci_bus_info
+#endif
+#ifdef VK_AMD_display_native_hdr
+#endif
+#ifdef VK_FUCHSIA_imagepipe_surface
+#endif
 #ifdef VK_EXT_metal_surface
 #endif
+#ifdef VK_EXT_fragment_density_map
+#endif
+#ifdef VK_EXT_scalar_block_layout
+#endif
+#ifdef VK_GOOGLE_hlsl_functionality1
+#endif
+#ifdef VK_GOOGLE_decorate_string
+#endif
 #ifdef VK_EXT_subgroup_size_control
 #endif
+#ifdef VK_AMD_shader_core_properties2
+#endif
+#ifdef VK_AMD_device_coherent_memory
+#endif
+#ifdef VK_EXT_shader_image_atomic_int64
+#endif
+#ifdef VK_EXT_memory_budget
+#endif
+#ifdef VK_EXT_memory_priority
+#endif
+#ifdef VK_NV_dedicated_allocation_image_aliasing
+#endif
+#ifdef VK_EXT_buffer_device_address
+#endif
+#ifdef VK_EXT_tooling_info
+#endif
+#ifdef VK_EXT_separate_stencil_usage
+#endif
+#ifdef VK_EXT_validation_features
+#endif
+#ifdef VK_NV_cooperative_matrix
+#endif
+#ifdef VK_NV_coverage_reduction_mode
+#endif
+#ifdef VK_EXT_fragment_shader_interlock
+#endif
+#ifdef VK_EXT_ycbcr_image_arrays
+#endif
 #ifdef VK_EXT_provoking_vertex
 #endif
+#ifdef VK_EXT_full_screen_exclusive
+#endif
+#ifdef VK_EXT_headless_surface
+#endif
 #ifdef VK_EXT_line_rasterization
             case OP_vkCmdSetLineStippleEXT: {
                 android::base::beginTrace("vkCmdSetLineStippleEXT subdecode");
@@ -2454,16 +4123,682 @@
                 break;
             }
 #endif
+#ifdef VK_EXT_shader_atomic_float
+#endif
+#ifdef VK_EXT_host_query_reset
+#endif
 #ifdef VK_EXT_index_type_uint8
 #endif
+#ifdef VK_EXT_extended_dynamic_state
+            case OP_vkCmdSetCullModeEXT: {
+                android::base::beginTrace("vkCmdSetCullModeEXT subdecode");
+                VkCullModeFlags cullMode;
+                memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
+                *readStreamPtrPtr += sizeof(VkCullModeFlags);
+                vk->vkCmdSetCullModeEXT((VkCommandBuffer)dispatchHandle, cullMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetFrontFaceEXT: {
+                android::base::beginTrace("vkCmdSetFrontFaceEXT subdecode");
+                VkFrontFace frontFace;
+                memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
+                *readStreamPtrPtr += sizeof(VkFrontFace);
+                vk->vkCmdSetFrontFaceEXT((VkCommandBuffer)dispatchHandle, frontFace);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPrimitiveTopologyEXT: {
+                android::base::beginTrace("vkCmdSetPrimitiveTopologyEXT subdecode");
+                VkPrimitiveTopology primitiveTopology;
+                memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
+                       sizeof(VkPrimitiveTopology));
+                *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
+                vk->vkCmdSetPrimitiveTopologyEXT((VkCommandBuffer)dispatchHandle,
+                                                 primitiveTopology);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetViewportWithCountEXT: {
+                android::base::beginTrace("vkCmdSetViewportWithCountEXT subdecode");
+                uint32_t viewportCount;
+                const VkViewport* pViewports;
+                VkViewport stack_pViewports[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((viewportCount)) <= MAX_STACK_ITEMS) {
+                    pViewports = (VkViewport*)stack_pViewports;
+                } else {
+                    readStream->alloc((void**)&pViewports,
+                                      ((viewportCount)) * sizeof(const VkViewport));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                    reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                 (VkViewport*)(pViewports + i), readStreamPtrPtr);
+                }
+                if (pViewports) {
+                    for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                        transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
+                    }
+                }
+                vk->vkCmdSetViewportWithCountEXT((VkCommandBuffer)dispatchHandle, viewportCount,
+                                                 pViewports);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetScissorWithCountEXT: {
+                android::base::beginTrace("vkCmdSetScissorWithCountEXT subdecode");
+                uint32_t scissorCount;
+                const VkRect2D* pScissors;
+                VkRect2D stack_pScissors[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((scissorCount)) <= MAX_STACK_ITEMS) {
+                    pScissors = (VkRect2D*)stack_pScissors;
+                } else {
+                    readStream->alloc((void**)&pScissors,
+                                      ((scissorCount)) * sizeof(const VkRect2D));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+                    reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                               (VkRect2D*)(pScissors + i), readStreamPtrPtr);
+                }
+                if (pScissors) {
+                    for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+                        transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
+                    }
+                }
+                vk->vkCmdSetScissorWithCountEXT((VkCommandBuffer)dispatchHandle, scissorCount,
+                                                pScissors);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBindVertexBuffers2EXT: {
+                android::base::beginTrace("vkCmdBindVertexBuffers2EXT subdecode");
+                uint32_t firstBinding;
+                uint32_t bindingCount;
+                const VkBuffer* pBuffers;
+                VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
+                const VkDeviceSize* pOffsets;
+                VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
+                const VkDeviceSize* pSizes;
+                VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
+                const VkDeviceSize* pStrides;
+                VkDeviceSize stack_pStrides[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pBuffers);
+                *readStreamPtrPtr += 8;
+                if (pBuffers) {
+                    if (((bindingCount)) <= MAX_STACK_ITEMS) {
+                        pBuffers = (VkBuffer*)stack_pBuffers;
+                    } else {
+                        readStream->alloc((void**)&pBuffers,
+                                          ((bindingCount)) * sizeof(const VkBuffer));
+                    }
+                    if (((bindingCount))) {
+                        uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
+                        *readStreamPtrPtr += 8 * ((bindingCount));
+                        for (uint32_t k = 0; k < ((bindingCount)); ++k) {
+                            uint64_t tmpval;
+                            memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
+                            *(((VkBuffer*)pBuffers) + k) =
+                                (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
+                        }
+                    }
+                }
+                if (((bindingCount)) <= MAX_STACK_ITEMS) {
+                    pOffsets = (VkDeviceSize*)stack_pOffsets;
+                } else {
+                    readStream->alloc((void**)&pOffsets,
+                                      ((bindingCount)) * sizeof(const VkDeviceSize));
+                }
+                memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
+                       ((bindingCount)) * sizeof(const VkDeviceSize));
+                *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+                // WARNING PTR CHECK
+                memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pSizes);
+                *readStreamPtrPtr += 8;
+                if (pSizes) {
+                    if (((bindingCount)) <= MAX_STACK_ITEMS) {
+                        pSizes = (VkDeviceSize*)stack_pSizes;
+                    } else {
+                        readStream->alloc((void**)&pSizes,
+                                          ((bindingCount)) * sizeof(const VkDeviceSize));
+                    }
+                    memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
+                           ((bindingCount)) * sizeof(const VkDeviceSize));
+                    *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+                }
+                // WARNING PTR CHECK
+                memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pStrides);
+                *readStreamPtrPtr += 8;
+                if (pStrides) {
+                    if (((bindingCount)) <= MAX_STACK_ITEMS) {
+                        pStrides = (VkDeviceSize*)stack_pStrides;
+                    } else {
+                        readStream->alloc((void**)&pStrides,
+                                          ((bindingCount)) * sizeof(const VkDeviceSize));
+                    }
+                    memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
+                           ((bindingCount)) * sizeof(const VkDeviceSize));
+                    *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+                }
+                vk->vkCmdBindVertexBuffers2EXT((VkCommandBuffer)dispatchHandle, firstBinding,
+                                               bindingCount, pBuffers, pOffsets, pSizes, pStrides);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthTestEnableEXT: {
+                android::base::beginTrace("vkCmdSetDepthTestEnableEXT subdecode");
+                VkBool32 depthTestEnable;
+                memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthTestEnableEXT((VkCommandBuffer)dispatchHandle, depthTestEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthWriteEnableEXT: {
+                android::base::beginTrace("vkCmdSetDepthWriteEnableEXT subdecode");
+                VkBool32 depthWriteEnable;
+                memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthWriteEnableEXT((VkCommandBuffer)dispatchHandle, depthWriteEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthCompareOpEXT: {
+                android::base::beginTrace("vkCmdSetDepthCompareOpEXT subdecode");
+                VkCompareOp depthCompareOp;
+                memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
+                *readStreamPtrPtr += sizeof(VkCompareOp);
+                vk->vkCmdSetDepthCompareOpEXT((VkCommandBuffer)dispatchHandle, depthCompareOp);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthBoundsTestEnableEXT: {
+                android::base::beginTrace("vkCmdSetDepthBoundsTestEnableEXT subdecode");
+                VkBool32 depthBoundsTestEnable;
+                memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthBoundsTestEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                     depthBoundsTestEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetStencilTestEnableEXT: {
+                android::base::beginTrace("vkCmdSetStencilTestEnableEXT subdecode");
+                VkBool32 stencilTestEnable;
+                memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetStencilTestEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                 stencilTestEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetStencilOpEXT: {
+                android::base::beginTrace("vkCmdSetStencilOpEXT subdecode");
+                VkStencilFaceFlags faceMask;
+                VkStencilOp failOp;
+                VkStencilOp passOp;
+                VkStencilOp depthFailOp;
+                VkCompareOp compareOp;
+                memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
+                       sizeof(VkStencilFaceFlags));
+                *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
+                memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+                *readStreamPtrPtr += sizeof(VkStencilOp);
+                memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+                *readStreamPtrPtr += sizeof(VkStencilOp);
+                memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+                *readStreamPtrPtr += sizeof(VkStencilOp);
+                memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
+                *readStreamPtrPtr += sizeof(VkCompareOp);
+                vk->vkCmdSetStencilOpEXT((VkCommandBuffer)dispatchHandle, faceMask, failOp, passOp,
+                                         depthFailOp, compareOp);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_shader_atomic_float2
+#endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+#endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
+#endif
+#ifdef VK_NV_device_generated_commands
+            case OP_vkCmdPreprocessGeneratedCommandsNV: {
+                android::base::beginTrace("vkCmdPreprocessGeneratedCommandsNV subdecode");
+                const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo;
+                VkGeneratedCommandsInfoNV stack_pGeneratedCommandsInfo[1];
+                pGeneratedCommandsInfo = (VkGeneratedCommandsInfoNV*)stack_pGeneratedCommandsInfo;
+                reservedunmarshal_VkGeneratedCommandsInfoNV(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo), readStreamPtrPtr);
+                if (pGeneratedCommandsInfo) {
+                    transform_tohost_VkGeneratedCommandsInfoNV(
+                        globalstate, (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo));
+                }
+                vk->vkCmdPreprocessGeneratedCommandsNV((VkCommandBuffer)dispatchHandle,
+                                                       pGeneratedCommandsInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdExecuteGeneratedCommandsNV: {
+                android::base::beginTrace("vkCmdExecuteGeneratedCommandsNV subdecode");
+                VkBool32 isPreprocessed;
+                const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo;
+                VkGeneratedCommandsInfoNV stack_pGeneratedCommandsInfo[1];
+                memcpy((VkBool32*)&isPreprocessed, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                pGeneratedCommandsInfo = (VkGeneratedCommandsInfoNV*)stack_pGeneratedCommandsInfo;
+                reservedunmarshal_VkGeneratedCommandsInfoNV(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo), readStreamPtrPtr);
+                if (pGeneratedCommandsInfo) {
+                    transform_tohost_VkGeneratedCommandsInfoNV(
+                        globalstate, (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo));
+                }
+                vk->vkCmdExecuteGeneratedCommandsNV((VkCommandBuffer)dispatchHandle, isPreprocessed,
+                                                    pGeneratedCommandsInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBindPipelineShaderGroupNV: {
+                android::base::beginTrace("vkCmdBindPipelineShaderGroupNV subdecode");
+                VkPipelineBindPoint pipelineBindPoint;
+                VkPipeline pipeline;
+                uint32_t groupIndex;
+                memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
+                       sizeof(VkPipelineBindPoint));
+                *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_0));
+                memcpy((uint32_t*)&groupIndex, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdBindPipelineShaderGroupNV((VkCommandBuffer)dispatchHandle,
+                                                   pipelineBindPoint, pipeline, groupIndex);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_inherited_viewport_scissor
+#endif
+#ifdef VK_EXT_texel_buffer_alignment
+#endif
+#ifdef VK_QCOM_render_pass_transform
+#endif
 #ifdef VK_EXT_device_memory_report
 #endif
+#ifdef VK_EXT_acquire_drm_display
+#endif
+#ifdef VK_EXT_robustness2
+#endif
 #ifdef VK_EXT_custom_border_color
 #endif
+#ifdef VK_GOOGLE_user_type
+#endif
+#ifdef VK_NV_present_barrier
+#endif
+#ifdef VK_EXT_private_data
+#endif
+#ifdef VK_EXT_pipeline_creation_cache_control
+#endif
+#ifdef VK_NV_device_diagnostics_config
+#endif
+#ifdef VK_QCOM_render_pass_store_ops
+#endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+#endif
+#ifdef VK_EXT_descriptor_buffer
+            case OP_vkCmdBindDescriptorBuffersEXT: {
+                android::base::beginTrace("vkCmdBindDescriptorBuffersEXT subdecode");
+                uint32_t bufferCount;
+                const VkDescriptorBufferBindingInfoEXT* pBindingInfos;
+                VkDescriptorBufferBindingInfoEXT stack_pBindingInfos[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&bufferCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((bufferCount)) <= MAX_STACK_ITEMS) {
+                    pBindingInfos = (VkDescriptorBufferBindingInfoEXT*)stack_pBindingInfos;
+                } else {
+                    readStream->alloc(
+                        (void**)&pBindingInfos,
+                        ((bufferCount)) * sizeof(const VkDescriptorBufferBindingInfoEXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((bufferCount)); ++i) {
+                    reservedunmarshal_VkDescriptorBufferBindingInfoEXT(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkDescriptorBufferBindingInfoEXT*)(pBindingInfos + i), readStreamPtrPtr);
+                }
+                if (pBindingInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((bufferCount)); ++i) {
+                        transform_tohost_VkDescriptorBufferBindingInfoEXT(
+                            globalstate, (VkDescriptorBufferBindingInfoEXT*)(pBindingInfos + i));
+                    }
+                }
+                vk->vkCmdBindDescriptorBuffersEXT((VkCommandBuffer)dispatchHandle, bufferCount,
+                                                  pBindingInfos);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDescriptorBufferOffsetsEXT: {
+                android::base::beginTrace("vkCmdSetDescriptorBufferOffsetsEXT subdecode");
+                VkPipelineBindPoint pipelineBindPoint;
+                VkPipelineLayout layout;
+                uint32_t firstSet;
+                uint32_t setCount;
+                const uint32_t* pBufferIndices;
+                uint32_t stack_pBufferIndices[MAX_STACK_ITEMS];
+                const VkDeviceSize* pOffsets;
+                VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
+                memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
+                       sizeof(VkPipelineBindPoint));
+                *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPipelineLayout*)&layout =
+                    (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
+                memcpy((uint32_t*)&firstSet, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&setCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((setCount)) <= MAX_STACK_ITEMS) {
+                    pBufferIndices = (uint32_t*)stack_pBufferIndices;
+                } else {
+                    readStream->alloc((void**)&pBufferIndices,
+                                      ((setCount)) * sizeof(const uint32_t));
+                }
+                memcpy((uint32_t*)pBufferIndices, *readStreamPtrPtr,
+                       ((setCount)) * sizeof(const uint32_t));
+                *readStreamPtrPtr += ((setCount)) * sizeof(const uint32_t);
+                if (((setCount)) <= MAX_STACK_ITEMS) {
+                    pOffsets = (VkDeviceSize*)stack_pOffsets;
+                } else {
+                    readStream->alloc((void**)&pOffsets, ((setCount)) * sizeof(const VkDeviceSize));
+                }
+                memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
+                       ((setCount)) * sizeof(const VkDeviceSize));
+                *readStreamPtrPtr += ((setCount)) * sizeof(const VkDeviceSize);
+                vk->vkCmdSetDescriptorBufferOffsetsEXT((VkCommandBuffer)dispatchHandle,
+                                                       pipelineBindPoint, layout, firstSet,
+                                                       setCount, pBufferIndices, pOffsets);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBindDescriptorBufferEmbeddedSamplersEXT: {
+                android::base::beginTrace("vkCmdBindDescriptorBufferEmbeddedSamplersEXT subdecode");
+                VkPipelineBindPoint pipelineBindPoint;
+                VkPipelineLayout layout;
+                uint32_t set;
+                memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
+                       sizeof(VkPipelineBindPoint));
+                *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPipelineLayout*)&layout =
+                    (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
+                memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdBindDescriptorBufferEmbeddedSamplersEXT((VkCommandBuffer)dispatchHandle,
+                                                                 pipelineBindPoint, layout, set);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
+#ifdef VK_NV_fragment_shading_rate_enums
+            case OP_vkCmdSetFragmentShadingRateEnumNV: {
+                android::base::beginTrace("vkCmdSetFragmentShadingRateEnumNV subdecode");
+                VkFragmentShadingRateNV shadingRate;
+                VkFragmentShadingRateCombinerOpKHR combinerOps[2];
+                memcpy((VkFragmentShadingRateNV*)&shadingRate, *readStreamPtrPtr,
+                       sizeof(VkFragmentShadingRateNV));
+                *readStreamPtrPtr += sizeof(VkFragmentShadingRateNV);
+                memcpy((VkFragmentShadingRateCombinerOpKHR*)combinerOps, *readStreamPtrPtr,
+                       2 * sizeof(const VkFragmentShadingRateCombinerOpKHR));
+                *readStreamPtrPtr += 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR);
+                vk->vkCmdSetFragmentShadingRateEnumNV((VkCommandBuffer)dispatchHandle, shadingRate,
+                                                      combinerOps);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_ray_tracing_motion_blur
+#endif
+#ifdef VK_EXT_ycbcr_2plane_444_formats
+#endif
+#ifdef VK_EXT_fragment_density_map2
+#endif
+#ifdef VK_QCOM_rotated_copy_commands
+#endif
 #ifdef VK_EXT_image_robustness
 #endif
+#ifdef VK_EXT_image_compression_control
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
+#ifdef VK_EXT_4444_formats
+#endif
+#ifdef VK_EXT_device_fault
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
+#ifdef VK_EXT_rgba10x6_formats
+#endif
+#ifdef VK_NV_acquire_winrt_display
+#endif
+#ifdef VK_EXT_directfb_surface
+#endif
+#ifdef VK_VALVE_mutable_descriptor_type
+#endif
+#ifdef VK_EXT_vertex_input_dynamic_state
+            case OP_vkCmdSetVertexInputEXT: {
+                android::base::beginTrace("vkCmdSetVertexInputEXT subdecode");
+                uint32_t vertexBindingDescriptionCount;
+                const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions;
+                VkVertexInputBindingDescription2EXT
+                    stack_pVertexBindingDescriptions[MAX_STACK_ITEMS];
+                uint32_t vertexAttributeDescriptionCount;
+                const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions;
+                VkVertexInputAttributeDescription2EXT
+                    stack_pVertexAttributeDescriptions[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&vertexBindingDescriptionCount, *readStreamPtrPtr,
+                       sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((vertexBindingDescriptionCount)) <= MAX_STACK_ITEMS) {
+                    pVertexBindingDescriptions =
+                        (VkVertexInputBindingDescription2EXT*)stack_pVertexBindingDescriptions;
+                } else {
+                    readStream->alloc((void**)&pVertexBindingDescriptions,
+                                      ((vertexBindingDescriptionCount)) *
+                                          sizeof(const VkVertexInputBindingDescription2EXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i) {
+                    reservedunmarshal_VkVertexInputBindingDescription2EXT(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkVertexInputBindingDescription2EXT*)(pVertexBindingDescriptions + i),
+                        readStreamPtrPtr);
+                }
+                memcpy((uint32_t*)&vertexAttributeDescriptionCount, *readStreamPtrPtr,
+                       sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((vertexAttributeDescriptionCount)) <= MAX_STACK_ITEMS) {
+                    pVertexAttributeDescriptions =
+                        (VkVertexInputAttributeDescription2EXT*)stack_pVertexAttributeDescriptions;
+                } else {
+                    readStream->alloc((void**)&pVertexAttributeDescriptions,
+                                      ((vertexAttributeDescriptionCount)) *
+                                          sizeof(const VkVertexInputAttributeDescription2EXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i) {
+                    reservedunmarshal_VkVertexInputAttributeDescription2EXT(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkVertexInputAttributeDescription2EXT*)(pVertexAttributeDescriptions + i),
+                        readStreamPtrPtr);
+                }
+                if (pVertexBindingDescriptions) {
+                    for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i) {
+                        transform_tohost_VkVertexInputBindingDescription2EXT(
+                            globalstate,
+                            (VkVertexInputBindingDescription2EXT*)(pVertexBindingDescriptions + i));
+                    }
+                }
+                if (pVertexAttributeDescriptions) {
+                    for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i) {
+                        transform_tohost_VkVertexInputAttributeDescription2EXT(
+                            globalstate,
+                            (VkVertexInputAttributeDescription2EXT*)(pVertexAttributeDescriptions +
+                                                                     i));
+                    }
+                }
+                vk->vkCmdSetVertexInputEXT(
+                    (VkCommandBuffer)dispatchHandle, vertexBindingDescriptionCount,
+                    pVertexBindingDescriptions, vertexAttributeDescriptionCount,
+                    pVertexAttributeDescriptions);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_physical_device_drm
+#endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
+#ifdef VK_FUCHSIA_external_memory
+#endif
+#ifdef VK_FUCHSIA_external_semaphore
+#endif
+#ifdef VK_FUCHSIA_buffer_collection
+#endif
+#ifdef VK_HUAWEI_subpass_shading
+            case OP_vkCmdSubpassShadingHUAWEI: {
+                android::base::beginTrace("vkCmdSubpassShadingHUAWEI subdecode");
+                vk->vkCmdSubpassShadingHUAWEI((VkCommandBuffer)dispatchHandle);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_HUAWEI_invocation_mask
+            case OP_vkCmdBindInvocationMaskHUAWEI: {
+                android::base::beginTrace("vkCmdBindInvocationMaskHUAWEI subdecode");
+                VkImageView imageView;
+                VkImageLayout imageLayout;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkImageView*)&imageView =
+                    (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_0));
+                memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
+                *readStreamPtrPtr += sizeof(VkImageLayout);
+                vk->vkCmdBindInvocationMaskHUAWEI((VkCommandBuffer)dispatchHandle, imageView,
+                                                  imageLayout);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_external_memory_rdma
+#endif
+#ifdef VK_EXT_pipeline_properties
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
+#ifdef VK_EXT_extended_dynamic_state2
+            case OP_vkCmdSetPatchControlPointsEXT: {
+                android::base::beginTrace("vkCmdSetPatchControlPointsEXT subdecode");
+                uint32_t patchControlPoints;
+                memcpy((uint32_t*)&patchControlPoints, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdSetPatchControlPointsEXT((VkCommandBuffer)dispatchHandle,
+                                                  patchControlPoints);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRasterizerDiscardEnableEXT: {
+                android::base::beginTrace("vkCmdSetRasterizerDiscardEnableEXT subdecode");
+                VkBool32 rasterizerDiscardEnable;
+                memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetRasterizerDiscardEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                       rasterizerDiscardEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthBiasEnableEXT: {
+                android::base::beginTrace("vkCmdSetDepthBiasEnableEXT subdecode");
+                VkBool32 depthBiasEnable;
+                memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthBiasEnableEXT((VkCommandBuffer)dispatchHandle, depthBiasEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetLogicOpEXT: {
+                android::base::beginTrace("vkCmdSetLogicOpEXT subdecode");
+                VkLogicOp logicOp;
+                memcpy((VkLogicOp*)&logicOp, *readStreamPtrPtr, sizeof(VkLogicOp));
+                *readStreamPtrPtr += sizeof(VkLogicOp);
+                vk->vkCmdSetLogicOpEXT((VkCommandBuffer)dispatchHandle, logicOp);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPrimitiveRestartEnableEXT: {
+                android::base::beginTrace("vkCmdSetPrimitiveRestartEnableEXT subdecode");
+                VkBool32 primitiveRestartEnable;
+                memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetPrimitiveRestartEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                      primitiveRestartEnable);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_QNX_screen_surface
+#endif
+#ifdef VK_EXT_color_write_enable
+            case OP_vkCmdSetColorWriteEnableEXT: {
+                android::base::beginTrace("vkCmdSetColorWriteEnableEXT subdecode");
+                uint32_t attachmentCount;
+                const VkBool32* pColorWriteEnables;
+                VkBool32 stack_pColorWriteEnables[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+                    pColorWriteEnables = (VkBool32*)stack_pColorWriteEnables;
+                } else {
+                    readStream->alloc((void**)&pColorWriteEnables,
+                                      ((attachmentCount)) * sizeof(const VkBool32));
+                }
+                memcpy((VkBool32*)pColorWriteEnables, *readStreamPtrPtr,
+                       ((attachmentCount)) * sizeof(const VkBool32));
+                *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkBool32);
+                vk->vkCmdSetColorWriteEnableEXT((VkCommandBuffer)dispatchHandle, attachmentCount,
+                                                pColorWriteEnables);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
 #ifdef VK_GOOGLE_gfxstream
             case OP_vkBeginCommandBufferAsyncGOOGLE: {
                 android::base::beginTrace("vkBeginCommandBufferAsyncGOOGLE subdecode");
@@ -2514,8 +4849,1350 @@
                 break;
             }
 #endif
+#ifdef VK_EXT_global_priority_query
+#endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
+#ifdef VK_EXT_multi_draw
+            case OP_vkCmdDrawMultiEXT: {
+                android::base::beginTrace("vkCmdDrawMultiEXT subdecode");
+                uint32_t drawCount;
+                const VkMultiDrawInfoEXT* pVertexInfo;
+                VkMultiDrawInfoEXT stack_pVertexInfo[MAX_STACK_ITEMS];
+                uint32_t instanceCount;
+                uint32_t firstInstance;
+                uint32_t stride;
+                memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((VkMultiDrawInfoEXT**)&pVertexInfo, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pVertexInfo);
+                *readStreamPtrPtr += 8;
+                if (pVertexInfo) {
+                    if (((drawCount)) <= MAX_STACK_ITEMS) {
+                        pVertexInfo = (VkMultiDrawInfoEXT*)stack_pVertexInfo;
+                    } else {
+                        readStream->alloc((void**)&pVertexInfo,
+                                          ((drawCount)) * sizeof(const VkMultiDrawInfoEXT));
+                    }
+                    for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+                        reservedunmarshal_VkMultiDrawInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                             (VkMultiDrawInfoEXT*)(pVertexInfo + i),
+                                                             readStreamPtrPtr);
+                    }
+                }
+                memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (pVertexInfo) {
+                    for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+                        transform_tohost_VkMultiDrawInfoEXT(globalstate,
+                                                            (VkMultiDrawInfoEXT*)(pVertexInfo + i));
+                    }
+                }
+                vk->vkCmdDrawMultiEXT((VkCommandBuffer)dispatchHandle, drawCount, pVertexInfo,
+                                      instanceCount, firstInstance, stride);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawMultiIndexedEXT: {
+                android::base::beginTrace("vkCmdDrawMultiIndexedEXT subdecode");
+                uint32_t drawCount;
+                const VkMultiDrawIndexedInfoEXT* pIndexInfo;
+                VkMultiDrawIndexedInfoEXT stack_pIndexInfo[MAX_STACK_ITEMS];
+                uint32_t instanceCount;
+                uint32_t firstInstance;
+                uint32_t stride;
+                const int32_t* pVertexOffset;
+                int32_t stack_pVertexOffset[1];
+                memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((VkMultiDrawIndexedInfoEXT**)&pIndexInfo, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pIndexInfo);
+                *readStreamPtrPtr += 8;
+                if (pIndexInfo) {
+                    if (((drawCount)) <= MAX_STACK_ITEMS) {
+                        pIndexInfo = (VkMultiDrawIndexedInfoEXT*)stack_pIndexInfo;
+                    } else {
+                        readStream->alloc((void**)&pIndexInfo,
+                                          ((drawCount)) * sizeof(const VkMultiDrawIndexedInfoEXT));
+                    }
+                    for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+                        reservedunmarshal_VkMultiDrawIndexedInfoEXT(
+                            readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                            (VkMultiDrawIndexedInfoEXT*)(pIndexInfo + i), readStreamPtrPtr);
+                    }
+                }
+                memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((int32_t**)&pVertexOffset, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pVertexOffset);
+                *readStreamPtrPtr += 8;
+                if (pVertexOffset) {
+                    pVertexOffset = (int32_t*)stack_pVertexOffset;
+                    memcpy((int32_t*)pVertexOffset, *readStreamPtrPtr, sizeof(const int32_t));
+                    *readStreamPtrPtr += sizeof(const int32_t);
+                }
+                if (pIndexInfo) {
+                    for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+                        transform_tohost_VkMultiDrawIndexedInfoEXT(
+                            globalstate, (VkMultiDrawIndexedInfoEXT*)(pIndexInfo + i));
+                    }
+                }
+                vk->vkCmdDrawMultiIndexedEXT((VkCommandBuffer)dispatchHandle, drawCount, pIndexInfo,
+                                             instanceCount, firstInstance, stride, pVertexOffset);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+            case OP_vkCmdBuildMicromapsEXT: {
+                android::base::beginTrace("vkCmdBuildMicromapsEXT subdecode");
+                uint32_t infoCount;
+                const VkMicromapBuildInfoEXT* pInfos;
+                VkMicromapBuildInfoEXT stack_pInfos[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((infoCount)) <= MAX_STACK_ITEMS) {
+                    pInfos = (VkMicromapBuildInfoEXT*)stack_pInfos;
+                } else {
+                    readStream->alloc((void**)&pInfos,
+                                      ((infoCount)) * sizeof(const VkMicromapBuildInfoEXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                    reservedunmarshal_VkMicromapBuildInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                             (VkMicromapBuildInfoEXT*)(pInfos + i),
+                                                             readStreamPtrPtr);
+                }
+                if (pInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                        transform_tohost_VkMicromapBuildInfoEXT(
+                            globalstate, (VkMicromapBuildInfoEXT*)(pInfos + i));
+                    }
+                }
+                vk->vkCmdBuildMicromapsEXT((VkCommandBuffer)dispatchHandle, infoCount, pInfos);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMicromapEXT: {
+                android::base::beginTrace("vkCmdCopyMicromapEXT subdecode");
+                const VkCopyMicromapInfoEXT* pInfo;
+                VkCopyMicromapInfoEXT stack_pInfo[1];
+                pInfo = (VkCopyMicromapInfoEXT*)stack_pInfo;
+                reservedunmarshal_VkCopyMicromapInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                        (VkCopyMicromapInfoEXT*)(pInfo),
+                                                        readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMicromapInfoEXT(globalstate,
+                                                           (VkCopyMicromapInfoEXT*)(pInfo));
+                }
+                vk->vkCmdCopyMicromapEXT((VkCommandBuffer)dispatchHandle, pInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMicromapToMemoryEXT: {
+                android::base::beginTrace("vkCmdCopyMicromapToMemoryEXT subdecode");
+                const VkCopyMicromapToMemoryInfoEXT* pInfo;
+                VkCopyMicromapToMemoryInfoEXT stack_pInfo[1];
+                pInfo = (VkCopyMicromapToMemoryInfoEXT*)stack_pInfo;
+                reservedunmarshal_VkCopyMicromapToMemoryInfoEXT(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMicromapToMemoryInfoEXT*)(pInfo),
+                    readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMicromapToMemoryInfoEXT(
+                        globalstate, (VkCopyMicromapToMemoryInfoEXT*)(pInfo));
+                }
+                vk->vkCmdCopyMicromapToMemoryEXT((VkCommandBuffer)dispatchHandle, pInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMemoryToMicromapEXT: {
+                android::base::beginTrace("vkCmdCopyMemoryToMicromapEXT subdecode");
+                const VkCopyMemoryToMicromapInfoEXT* pInfo;
+                VkCopyMemoryToMicromapInfoEXT stack_pInfo[1];
+                pInfo = (VkCopyMemoryToMicromapInfoEXT*)stack_pInfo;
+                reservedunmarshal_VkCopyMemoryToMicromapInfoEXT(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToMicromapInfoEXT*)(pInfo),
+                    readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMemoryToMicromapInfoEXT(
+                        globalstate, (VkCopyMemoryToMicromapInfoEXT*)(pInfo));
+                }
+                vk->vkCmdCopyMemoryToMicromapEXT((VkCommandBuffer)dispatchHandle, pInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWriteMicromapsPropertiesEXT: {
+                android::base::beginTrace("vkCmdWriteMicromapsPropertiesEXT subdecode");
+                uint32_t micromapCount;
+                const VkMicromapEXT* pMicromaps;
+                VkMicromapEXT stack_pMicromaps[MAX_STACK_ITEMS];
+                VkQueryType queryType;
+                VkQueryPool queryPool;
+                uint32_t firstQuery;
+                memcpy((uint32_t*)&micromapCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((micromapCount)) <= MAX_STACK_ITEMS) {
+                    pMicromaps = (VkMicromapEXT*)stack_pMicromaps;
+                } else {
+                    readStream->alloc((void**)&pMicromaps,
+                                      ((micromapCount)) * sizeof(const VkMicromapEXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((micromapCount)); ++i) {
+                    memcpy((VkMicromapEXT*)&pMicromaps[i], (*readStreamPtrPtr), 8);
+                    android::base::Stream::fromBe64((uint8_t*)&pMicromaps[i]);
+                    *readStreamPtrPtr += 8;
+                }
+                memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
+                *readStreamPtrPtr += sizeof(VkQueryType);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkQueryPool*)&queryPool =
+                    (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
+                memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdWriteMicromapsPropertiesEXT((VkCommandBuffer)dispatchHandle, micromapCount,
+                                                     pMicromaps, queryType, queryPool, firstQuery);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+            case OP_vkCmdDrawClusterHUAWEI: {
+                android::base::beginTrace("vkCmdDrawClusterHUAWEI subdecode");
+                uint32_t groupCountX;
+                uint32_t groupCountY;
+                uint32_t groupCountZ;
+                memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawClusterHUAWEI((VkCommandBuffer)dispatchHandle, groupCountX,
+                                           groupCountY, groupCountZ);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawClusterIndirectHUAWEI: {
+                android::base::beginTrace("vkCmdDrawClusterIndirectHUAWEI subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                vk->vkCmdDrawClusterIndirectHUAWEI((VkCommandBuffer)dispatchHandle, buffer, offset);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_border_color_swizzle
+#endif
+#ifdef VK_EXT_pageable_device_local_memory
+#endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+            case OP_vkCmdCopyMemoryIndirectNV: {
+                android::base::beginTrace("vkCmdCopyMemoryIndirectNV subdecode");
+                VkDeviceAddress copyBufferAddress;
+                uint32_t copyCount;
+                uint32_t stride;
+                memcpy((VkDeviceAddress*)&copyBufferAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((uint32_t*)&copyCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdCopyMemoryIndirectNV((VkCommandBuffer)dispatchHandle, copyBufferAddress,
+                                              copyCount, stride);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMemoryToImageIndirectNV: {
+                android::base::beginTrace("vkCmdCopyMemoryToImageIndirectNV subdecode");
+                VkDeviceAddress copyBufferAddress;
+                uint32_t copyCount;
+                uint32_t stride;
+                VkImage dstImage;
+                VkImageLayout dstImageLayout;
+                const VkImageSubresourceLayers* pImageSubresources;
+                VkImageSubresourceLayers stack_pImageSubresources[MAX_STACK_ITEMS];
+                memcpy((VkDeviceAddress*)&copyBufferAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((uint32_t*)&copyCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+                memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
+                *readStreamPtrPtr += sizeof(VkImageLayout);
+                if (((copyCount)) <= MAX_STACK_ITEMS) {
+                    pImageSubresources = (VkImageSubresourceLayers*)stack_pImageSubresources;
+                } else {
+                    readStream->alloc((void**)&pImageSubresources,
+                                      ((copyCount)) * sizeof(const VkImageSubresourceLayers));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((copyCount)); ++i) {
+                    reservedunmarshal_VkImageSubresourceLayers(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkImageSubresourceLayers*)(pImageSubresources + i), readStreamPtrPtr);
+                }
+                if (pImageSubresources) {
+                    for (uint32_t i = 0; i < (uint32_t)((copyCount)); ++i) {
+                        transform_tohost_VkImageSubresourceLayers(
+                            globalstate, (VkImageSubresourceLayers*)(pImageSubresources + i));
+                    }
+                }
+                vk->vkCmdCopyMemoryToImageIndirectNV((VkCommandBuffer)dispatchHandle,
+                                                     copyBufferAddress, copyCount, stride, dstImage,
+                                                     dstImageLayout, pImageSubresources);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_memory_decompression
+            case OP_vkCmdDecompressMemoryNV: {
+                android::base::beginTrace("vkCmdDecompressMemoryNV subdecode");
+                uint32_t decompressRegionCount;
+                const VkDecompressMemoryRegionNV* pDecompressMemoryRegions;
+                VkDecompressMemoryRegionNV stack_pDecompressMemoryRegions[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&decompressRegionCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((decompressRegionCount)) <= MAX_STACK_ITEMS) {
+                    pDecompressMemoryRegions =
+                        (VkDecompressMemoryRegionNV*)stack_pDecompressMemoryRegions;
+                } else {
+                    readStream->alloc(
+                        (void**)&pDecompressMemoryRegions,
+                        ((decompressRegionCount)) * sizeof(const VkDecompressMemoryRegionNV));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((decompressRegionCount)); ++i) {
+                    reservedunmarshal_VkDecompressMemoryRegionNV(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkDecompressMemoryRegionNV*)(pDecompressMemoryRegions + i),
+                        readStreamPtrPtr);
+                }
+                if (pDecompressMemoryRegions) {
+                    for (uint32_t i = 0; i < (uint32_t)((decompressRegionCount)); ++i) {
+                        transform_tohost_VkDecompressMemoryRegionNV(
+                            globalstate,
+                            (VkDecompressMemoryRegionNV*)(pDecompressMemoryRegions + i));
+                    }
+                }
+                vk->vkCmdDecompressMemoryNV((VkCommandBuffer)dispatchHandle, decompressRegionCount,
+                                            pDecompressMemoryRegions);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDecompressMemoryIndirectCountNV: {
+                android::base::beginTrace("vkCmdDecompressMemoryIndirectCountNV subdecode");
+                VkDeviceAddress indirectCommandsAddress;
+                VkDeviceAddress indirectCommandsCountAddress;
+                uint32_t stride;
+                memcpy((VkDeviceAddress*)&indirectCommandsAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((VkDeviceAddress*)&indirectCommandsCountAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDecompressMemoryIndirectCountNV((VkCommandBuffer)dispatchHandle,
+                                                         indirectCommandsAddress,
+                                                         indirectCommandsCountAddress, stride);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+            case OP_vkCmdSetTessellationDomainOriginEXT: {
+                android::base::beginTrace("vkCmdSetTessellationDomainOriginEXT subdecode");
+                VkTessellationDomainOrigin domainOrigin;
+                memcpy((VkTessellationDomainOrigin*)&domainOrigin, *readStreamPtrPtr,
+                       sizeof(VkTessellationDomainOrigin));
+                *readStreamPtrPtr += sizeof(VkTessellationDomainOrigin);
+                vk->vkCmdSetTessellationDomainOriginEXT((VkCommandBuffer)dispatchHandle,
+                                                        domainOrigin);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthClampEnableEXT: {
+                android::base::beginTrace("vkCmdSetDepthClampEnableEXT subdecode");
+                VkBool32 depthClampEnable;
+                memcpy((VkBool32*)&depthClampEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthClampEnableEXT((VkCommandBuffer)dispatchHandle, depthClampEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPolygonModeEXT: {
+                android::base::beginTrace("vkCmdSetPolygonModeEXT subdecode");
+                VkPolygonMode polygonMode;
+                memcpy((VkPolygonMode*)&polygonMode, *readStreamPtrPtr, sizeof(VkPolygonMode));
+                *readStreamPtrPtr += sizeof(VkPolygonMode);
+                vk->vkCmdSetPolygonModeEXT((VkCommandBuffer)dispatchHandle, polygonMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRasterizationSamplesEXT: {
+                android::base::beginTrace("vkCmdSetRasterizationSamplesEXT subdecode");
+                VkSampleCountFlagBits rasterizationSamples;
+                memcpy((VkSampleCountFlagBits*)&rasterizationSamples, *readStreamPtrPtr,
+                       sizeof(VkSampleCountFlagBits));
+                *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
+                vk->vkCmdSetRasterizationSamplesEXT((VkCommandBuffer)dispatchHandle,
+                                                    rasterizationSamples);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetSampleMaskEXT: {
+                android::base::beginTrace("vkCmdSetSampleMaskEXT subdecode");
+                VkSampleCountFlagBits samples;
+                const VkSampleMask* pSampleMask;
+                VkSampleMask stack_pSampleMask[MAX_STACK_ITEMS];
+                memcpy((VkSampleCountFlagBits*)&samples, *readStreamPtrPtr,
+                       sizeof(VkSampleCountFlagBits));
+                *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
+                if (int(samples / 32) <= MAX_STACK_ITEMS) {
+                    pSampleMask = (VkSampleMask*)stack_pSampleMask;
+                } else {
+                    readStream->alloc((void**)&pSampleMask,
+                                      int(samples / 32) * sizeof(const VkSampleMask));
+                }
+                memcpy((VkSampleMask*)pSampleMask, *readStreamPtrPtr,
+                       int(samples / 32) * sizeof(const VkSampleMask));
+                *readStreamPtrPtr += int(samples / 32) * sizeof(const VkSampleMask);
+                vk->vkCmdSetSampleMaskEXT((VkCommandBuffer)dispatchHandle, samples, pSampleMask);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetAlphaToCoverageEnableEXT: {
+                android::base::beginTrace("vkCmdSetAlphaToCoverageEnableEXT subdecode");
+                VkBool32 alphaToCoverageEnable;
+                memcpy((VkBool32*)&alphaToCoverageEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetAlphaToCoverageEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                     alphaToCoverageEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetAlphaToOneEnableEXT: {
+                android::base::beginTrace("vkCmdSetAlphaToOneEnableEXT subdecode");
+                VkBool32 alphaToOneEnable;
+                memcpy((VkBool32*)&alphaToOneEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetAlphaToOneEnableEXT((VkCommandBuffer)dispatchHandle, alphaToOneEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetLogicOpEnableEXT: {
+                android::base::beginTrace("vkCmdSetLogicOpEnableEXT subdecode");
+                VkBool32 logicOpEnable;
+                memcpy((VkBool32*)&logicOpEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetLogicOpEnableEXT((VkCommandBuffer)dispatchHandle, logicOpEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorBlendEnableEXT: {
+                android::base::beginTrace("vkCmdSetColorBlendEnableEXT subdecode");
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkBool32* pColorBlendEnables;
+                VkBool32 stack_pColorBlendEnables[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+                    pColorBlendEnables = (VkBool32*)stack_pColorBlendEnables;
+                } else {
+                    readStream->alloc((void**)&pColorBlendEnables,
+                                      ((attachmentCount)) * sizeof(const VkBool32));
+                }
+                memcpy((VkBool32*)pColorBlendEnables, *readStreamPtrPtr,
+                       ((attachmentCount)) * sizeof(const VkBool32));
+                *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkBool32);
+                vk->vkCmdSetColorBlendEnableEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+                                                attachmentCount, pColorBlendEnables);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorBlendEquationEXT: {
+                android::base::beginTrace("vkCmdSetColorBlendEquationEXT subdecode");
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkColorBlendEquationEXT* pColorBlendEquations;
+                VkColorBlendEquationEXT stack_pColorBlendEquations[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+                    pColorBlendEquations = (VkColorBlendEquationEXT*)stack_pColorBlendEquations;
+                } else {
+                    readStream->alloc((void**)&pColorBlendEquations,
+                                      ((attachmentCount)) * sizeof(const VkColorBlendEquationEXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                    reservedunmarshal_VkColorBlendEquationEXT(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkColorBlendEquationEXT*)(pColorBlendEquations + i), readStreamPtrPtr);
+                }
+                if (pColorBlendEquations) {
+                    for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                        transform_tohost_VkColorBlendEquationEXT(
+                            globalstate, (VkColorBlendEquationEXT*)(pColorBlendEquations + i));
+                    }
+                }
+                vk->vkCmdSetColorBlendEquationEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+                                                  attachmentCount, pColorBlendEquations);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorWriteMaskEXT: {
+                android::base::beginTrace("vkCmdSetColorWriteMaskEXT subdecode");
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkColorComponentFlags* pColorWriteMasks;
+                VkColorComponentFlags stack_pColorWriteMasks[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((VkColorComponentFlags**)&pColorWriteMasks, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pColorWriteMasks);
+                *readStreamPtrPtr += 8;
+                if (pColorWriteMasks) {
+                    if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+                        pColorWriteMasks = (VkColorComponentFlags*)stack_pColorWriteMasks;
+                    } else {
+                        readStream->alloc(
+                            (void**)&pColorWriteMasks,
+                            ((attachmentCount)) * sizeof(const VkColorComponentFlags));
+                    }
+                    memcpy((VkColorComponentFlags*)pColorWriteMasks, *readStreamPtrPtr,
+                           ((attachmentCount)) * sizeof(const VkColorComponentFlags));
+                    *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkColorComponentFlags);
+                }
+                vk->vkCmdSetColorWriteMaskEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+                                              attachmentCount, pColorWriteMasks);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRasterizationStreamEXT: {
+                android::base::beginTrace("vkCmdSetRasterizationStreamEXT subdecode");
+                uint32_t rasterizationStream;
+                memcpy((uint32_t*)&rasterizationStream, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdSetRasterizationStreamEXT((VkCommandBuffer)dispatchHandle,
+                                                   rasterizationStream);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetConservativeRasterizationModeEXT: {
+                android::base::beginTrace("vkCmdSetConservativeRasterizationModeEXT subdecode");
+                VkConservativeRasterizationModeEXT conservativeRasterizationMode;
+                memcpy((VkConservativeRasterizationModeEXT*)&conservativeRasterizationMode,
+                       *readStreamPtrPtr, sizeof(VkConservativeRasterizationModeEXT));
+                *readStreamPtrPtr += sizeof(VkConservativeRasterizationModeEXT);
+                vk->vkCmdSetConservativeRasterizationModeEXT((VkCommandBuffer)dispatchHandle,
+                                                             conservativeRasterizationMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetExtraPrimitiveOverestimationSizeEXT: {
+                android::base::beginTrace("vkCmdSetExtraPrimitiveOverestimationSizeEXT subdecode");
+                float extraPrimitiveOverestimationSize;
+                memcpy((float*)&extraPrimitiveOverestimationSize, *readStreamPtrPtr, sizeof(float));
+                *readStreamPtrPtr += sizeof(float);
+                vk->vkCmdSetExtraPrimitiveOverestimationSizeEXT((VkCommandBuffer)dispatchHandle,
+                                                                extraPrimitiveOverestimationSize);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthClipEnableEXT: {
+                android::base::beginTrace("vkCmdSetDepthClipEnableEXT subdecode");
+                VkBool32 depthClipEnable;
+                memcpy((VkBool32*)&depthClipEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthClipEnableEXT((VkCommandBuffer)dispatchHandle, depthClipEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetSampleLocationsEnableEXT: {
+                android::base::beginTrace("vkCmdSetSampleLocationsEnableEXT subdecode");
+                VkBool32 sampleLocationsEnable;
+                memcpy((VkBool32*)&sampleLocationsEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetSampleLocationsEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                     sampleLocationsEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorBlendAdvancedEXT: {
+                android::base::beginTrace("vkCmdSetColorBlendAdvancedEXT subdecode");
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkColorBlendAdvancedEXT* pColorBlendAdvanced;
+                VkColorBlendAdvancedEXT stack_pColorBlendAdvanced[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+                    pColorBlendAdvanced = (VkColorBlendAdvancedEXT*)stack_pColorBlendAdvanced;
+                } else {
+                    readStream->alloc((void**)&pColorBlendAdvanced,
+                                      ((attachmentCount)) * sizeof(const VkColorBlendAdvancedEXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                    reservedunmarshal_VkColorBlendAdvancedEXT(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkColorBlendAdvancedEXT*)(pColorBlendAdvanced + i), readStreamPtrPtr);
+                }
+                if (pColorBlendAdvanced) {
+                    for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                        transform_tohost_VkColorBlendAdvancedEXT(
+                            globalstate, (VkColorBlendAdvancedEXT*)(pColorBlendAdvanced + i));
+                    }
+                }
+                vk->vkCmdSetColorBlendAdvancedEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+                                                  attachmentCount, pColorBlendAdvanced);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetProvokingVertexModeEXT: {
+                android::base::beginTrace("vkCmdSetProvokingVertexModeEXT subdecode");
+                VkProvokingVertexModeEXT provokingVertexMode;
+                memcpy((VkProvokingVertexModeEXT*)&provokingVertexMode, *readStreamPtrPtr,
+                       sizeof(VkProvokingVertexModeEXT));
+                *readStreamPtrPtr += sizeof(VkProvokingVertexModeEXT);
+                vk->vkCmdSetProvokingVertexModeEXT((VkCommandBuffer)dispatchHandle,
+                                                   provokingVertexMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetLineRasterizationModeEXT: {
+                android::base::beginTrace("vkCmdSetLineRasterizationModeEXT subdecode");
+                VkLineRasterizationModeEXT lineRasterizationMode;
+                memcpy((VkLineRasterizationModeEXT*)&lineRasterizationMode, *readStreamPtrPtr,
+                       sizeof(VkLineRasterizationModeEXT));
+                *readStreamPtrPtr += sizeof(VkLineRasterizationModeEXT);
+                vk->vkCmdSetLineRasterizationModeEXT((VkCommandBuffer)dispatchHandle,
+                                                     lineRasterizationMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetLineStippleEnableEXT: {
+                android::base::beginTrace("vkCmdSetLineStippleEnableEXT subdecode");
+                VkBool32 stippledLineEnable;
+                memcpy((VkBool32*)&stippledLineEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetLineStippleEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                 stippledLineEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthClipNegativeOneToOneEXT: {
+                android::base::beginTrace("vkCmdSetDepthClipNegativeOneToOneEXT subdecode");
+                VkBool32 negativeOneToOne;
+                memcpy((VkBool32*)&negativeOneToOne, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthClipNegativeOneToOneEXT((VkCommandBuffer)dispatchHandle,
+                                                         negativeOneToOne);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetViewportWScalingEnableNV: {
+                android::base::beginTrace("vkCmdSetViewportWScalingEnableNV subdecode");
+                VkBool32 viewportWScalingEnable;
+                memcpy((VkBool32*)&viewportWScalingEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetViewportWScalingEnableNV((VkCommandBuffer)dispatchHandle,
+                                                     viewportWScalingEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetViewportSwizzleNV: {
+                android::base::beginTrace("vkCmdSetViewportSwizzleNV subdecode");
+                uint32_t firstViewport;
+                uint32_t viewportCount;
+                const VkViewportSwizzleNV* pViewportSwizzles;
+                VkViewportSwizzleNV stack_pViewportSwizzles[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((viewportCount)) <= MAX_STACK_ITEMS) {
+                    pViewportSwizzles = (VkViewportSwizzleNV*)stack_pViewportSwizzles;
+                } else {
+                    readStream->alloc((void**)&pViewportSwizzles,
+                                      ((viewportCount)) * sizeof(const VkViewportSwizzleNV));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                    reservedunmarshal_VkViewportSwizzleNV(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkViewportSwizzleNV*)(pViewportSwizzles + i), readStreamPtrPtr);
+                }
+                if (pViewportSwizzles) {
+                    for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                        transform_tohost_VkViewportSwizzleNV(
+                            globalstate, (VkViewportSwizzleNV*)(pViewportSwizzles + i));
+                    }
+                }
+                vk->vkCmdSetViewportSwizzleNV((VkCommandBuffer)dispatchHandle, firstViewport,
+                                              viewportCount, pViewportSwizzles);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageToColorEnableNV: {
+                android::base::beginTrace("vkCmdSetCoverageToColorEnableNV subdecode");
+                VkBool32 coverageToColorEnable;
+                memcpy((VkBool32*)&coverageToColorEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetCoverageToColorEnableNV((VkCommandBuffer)dispatchHandle,
+                                                    coverageToColorEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageToColorLocationNV: {
+                android::base::beginTrace("vkCmdSetCoverageToColorLocationNV subdecode");
+                uint32_t coverageToColorLocation;
+                memcpy((uint32_t*)&coverageToColorLocation, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdSetCoverageToColorLocationNV((VkCommandBuffer)dispatchHandle,
+                                                      coverageToColorLocation);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageModulationModeNV: {
+                android::base::beginTrace("vkCmdSetCoverageModulationModeNV subdecode");
+                VkCoverageModulationModeNV coverageModulationMode;
+                memcpy((VkCoverageModulationModeNV*)&coverageModulationMode, *readStreamPtrPtr,
+                       sizeof(VkCoverageModulationModeNV));
+                *readStreamPtrPtr += sizeof(VkCoverageModulationModeNV);
+                vk->vkCmdSetCoverageModulationModeNV((VkCommandBuffer)dispatchHandle,
+                                                     coverageModulationMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageModulationTableEnableNV: {
+                android::base::beginTrace("vkCmdSetCoverageModulationTableEnableNV subdecode");
+                VkBool32 coverageModulationTableEnable;
+                memcpy((VkBool32*)&coverageModulationTableEnable, *readStreamPtrPtr,
+                       sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetCoverageModulationTableEnableNV((VkCommandBuffer)dispatchHandle,
+                                                            coverageModulationTableEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageModulationTableNV: {
+                android::base::beginTrace("vkCmdSetCoverageModulationTableNV subdecode");
+                uint32_t coverageModulationTableCount;
+                const float* pCoverageModulationTable;
+                float stack_pCoverageModulationTable[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&coverageModulationTableCount, *readStreamPtrPtr,
+                       sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((coverageModulationTableCount)) <= MAX_STACK_ITEMS) {
+                    pCoverageModulationTable = (float*)stack_pCoverageModulationTable;
+                } else {
+                    readStream->alloc((void**)&pCoverageModulationTable,
+                                      ((coverageModulationTableCount)) * sizeof(const float));
+                }
+                memcpy((float*)pCoverageModulationTable, *readStreamPtrPtr,
+                       ((coverageModulationTableCount)) * sizeof(const float));
+                *readStreamPtrPtr += ((coverageModulationTableCount)) * sizeof(const float);
+                vk->vkCmdSetCoverageModulationTableNV((VkCommandBuffer)dispatchHandle,
+                                                      coverageModulationTableCount,
+                                                      pCoverageModulationTable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetShadingRateImageEnableNV: {
+                android::base::beginTrace("vkCmdSetShadingRateImageEnableNV subdecode");
+                VkBool32 shadingRateImageEnable;
+                memcpy((VkBool32*)&shadingRateImageEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetShadingRateImageEnableNV((VkCommandBuffer)dispatchHandle,
+                                                     shadingRateImageEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRepresentativeFragmentTestEnableNV: {
+                android::base::beginTrace("vkCmdSetRepresentativeFragmentTestEnableNV subdecode");
+                VkBool32 representativeFragmentTestEnable;
+                memcpy((VkBool32*)&representativeFragmentTestEnable, *readStreamPtrPtr,
+                       sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetRepresentativeFragmentTestEnableNV((VkCommandBuffer)dispatchHandle,
+                                                               representativeFragmentTestEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageReductionModeNV: {
+                android::base::beginTrace("vkCmdSetCoverageReductionModeNV subdecode");
+                VkCoverageReductionModeNV coverageReductionMode;
+                memcpy((VkCoverageReductionModeNV*)&coverageReductionMode, *readStreamPtrPtr,
+                       sizeof(VkCoverageReductionModeNV));
+                *readStreamPtrPtr += sizeof(VkCoverageReductionModeNV);
+                vk->vkCmdSetCoverageReductionModeNV((VkCommandBuffer)dispatchHandle,
+                                                    coverageReductionMode);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+            case OP_vkCmdOpticalFlowExecuteNV: {
+                android::base::beginTrace("vkCmdOpticalFlowExecuteNV subdecode");
+                VkOpticalFlowSessionNV session;
+                const VkOpticalFlowExecuteInfoNV* pExecuteInfo;
+                VkOpticalFlowExecuteInfoNV stack_pExecuteInfo[1];
+                memcpy((VkOpticalFlowSessionNV*)&session, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&session);
+                *readStreamPtrPtr += 8;
+                pExecuteInfo = (VkOpticalFlowExecuteInfoNV*)stack_pExecuteInfo;
+                reservedunmarshal_VkOpticalFlowExecuteInfoNV(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkOpticalFlowExecuteInfoNV*)(pExecuteInfo), readStreamPtrPtr);
+                if (pExecuteInfo) {
+                    transform_tohost_VkOpticalFlowExecuteInfoNV(
+                        globalstate, (VkOpticalFlowExecuteInfoNV*)(pExecuteInfo));
+                }
+                vk->vkCmdOpticalFlowExecuteNV((VkCommandBuffer)dispatchHandle, session,
+                                              pExecuteInfo);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+            case OP_vkCmdBindShadersEXT: {
+                android::base::beginTrace("vkCmdBindShadersEXT subdecode");
+                uint32_t stageCount;
+                const VkShaderStageFlagBits* pStages;
+                VkShaderStageFlagBits stack_pStages[MAX_STACK_ITEMS];
+                const VkShaderEXT* pShaders;
+                VkShaderEXT stack_pShaders[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&stageCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((stageCount)) <= MAX_STACK_ITEMS) {
+                    pStages = (VkShaderStageFlagBits*)stack_pStages;
+                } else {
+                    readStream->alloc((void**)&pStages,
+                                      ((stageCount)) * sizeof(const VkShaderStageFlagBits));
+                }
+                memcpy((VkShaderStageFlagBits*)pStages, *readStreamPtrPtr,
+                       ((stageCount)) * sizeof(const VkShaderStageFlagBits));
+                *readStreamPtrPtr += ((stageCount)) * sizeof(const VkShaderStageFlagBits);
+                // WARNING PTR CHECK
+                memcpy((VkShaderEXT**)&pShaders, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pShaders);
+                *readStreamPtrPtr += 8;
+                if (pShaders) {
+                    if (((stageCount)) <= MAX_STACK_ITEMS) {
+                        pShaders = (VkShaderEXT*)stack_pShaders;
+                    } else {
+                        readStream->alloc((void**)&pShaders,
+                                          ((stageCount)) * sizeof(const VkShaderEXT));
+                    }
+                    for (uint32_t i = 0; i < (uint32_t)((stageCount)); ++i) {
+                        memcpy((VkShaderEXT*)&pShaders[i], (*readStreamPtrPtr), 8);
+                        android::base::Stream::fromBe64((uint8_t*)&pShaders[i]);
+                        *readStreamPtrPtr += 8;
+                    }
+                }
+                vk->vkCmdBindShadersEXT((VkCommandBuffer)dispatchHandle, stageCount, pStages,
+                                        pShaders);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_QCOM_tile_properties
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+            case OP_vkCmdSetAttachmentFeedbackLoopEnableEXT: {
+                android::base::beginTrace("vkCmdSetAttachmentFeedbackLoopEnableEXT subdecode");
+                VkImageAspectFlags aspectMask;
+                memcpy((VkImageAspectFlags*)&aspectMask, *readStreamPtrPtr,
+                       sizeof(VkImageAspectFlags));
+                *readStreamPtrPtr += sizeof(VkImageAspectFlags);
+                vk->vkCmdSetAttachmentFeedbackLoopEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                            aspectMask);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_acceleration_structure
+            case OP_vkCmdBuildAccelerationStructuresKHR: {
+                android::base::beginTrace("vkCmdBuildAccelerationStructuresKHR subdecode");
+                uint32_t infoCount;
+                const VkAccelerationStructureBuildGeometryInfoKHR* pInfos;
+                VkAccelerationStructureBuildGeometryInfoKHR stack_pInfos[MAX_STACK_ITEMS];
+                const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos;
+                VkAccelerationStructureBuildRangeInfoKHR* stack_ppBuildRangeInfos[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((infoCount)) <= MAX_STACK_ITEMS) {
+                    pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)stack_pInfos;
+                } else {
+                    readStream->alloc(
+                        (void**)&pInfos,
+                        ((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                    reservedunmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i),
+                        readStreamPtrPtr);
+                }
+                if (pInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                        transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(
+                            globalstate,
+                            (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i));
+                    }
+                }
+                (void)ppBuildRangeInfos;
+                vk->vkCmdBuildAccelerationStructuresKHR((VkCommandBuffer)dispatchHandle, infoCount,
+                                                        pInfos, ppBuildRangeInfos);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBuildAccelerationStructuresIndirectKHR: {
+                android::base::beginTrace("vkCmdBuildAccelerationStructuresIndirectKHR subdecode");
+                uint32_t infoCount;
+                const VkAccelerationStructureBuildGeometryInfoKHR* pInfos;
+                VkAccelerationStructureBuildGeometryInfoKHR stack_pInfos[MAX_STACK_ITEMS];
+                const VkDeviceAddress* pIndirectDeviceAddresses;
+                VkDeviceAddress stack_pIndirectDeviceAddresses[MAX_STACK_ITEMS];
+                const uint32_t* pIndirectStrides;
+                uint32_t stack_pIndirectStrides[MAX_STACK_ITEMS];
+                const uint32_t* const* ppMaxPrimitiveCounts;
+                uint32_t* stack_ppMaxPrimitiveCounts[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((infoCount)) <= MAX_STACK_ITEMS) {
+                    pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)stack_pInfos;
+                } else {
+                    readStream->alloc(
+                        (void**)&pInfos,
+                        ((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                    reservedunmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i),
+                        readStreamPtrPtr);
+                }
+                if (((infoCount)) <= MAX_STACK_ITEMS) {
+                    pIndirectDeviceAddresses = (VkDeviceAddress*)stack_pIndirectDeviceAddresses;
+                } else {
+                    readStream->alloc((void**)&pIndirectDeviceAddresses,
+                                      ((infoCount)) * sizeof(const VkDeviceAddress));
+                }
+                memcpy((VkDeviceAddress*)pIndirectDeviceAddresses, *readStreamPtrPtr,
+                       ((infoCount)) * sizeof(const VkDeviceAddress));
+                *readStreamPtrPtr += ((infoCount)) * sizeof(const VkDeviceAddress);
+                if (((infoCount)) <= MAX_STACK_ITEMS) {
+                    pIndirectStrides = (uint32_t*)stack_pIndirectStrides;
+                } else {
+                    readStream->alloc((void**)&pIndirectStrides,
+                                      ((infoCount)) * sizeof(const uint32_t));
+                }
+                memcpy((uint32_t*)pIndirectStrides, *readStreamPtrPtr,
+                       ((infoCount)) * sizeof(const uint32_t));
+                *readStreamPtrPtr += ((infoCount)) * sizeof(const uint32_t);
+                if (pInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                        transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(
+                            globalstate,
+                            (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i));
+                    }
+                }
+                (void)ppMaxPrimitiveCounts;
+                vk->vkCmdBuildAccelerationStructuresIndirectKHR(
+                    (VkCommandBuffer)dispatchHandle, infoCount, pInfos, pIndirectDeviceAddresses,
+                    pIndirectStrides, ppMaxPrimitiveCounts);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyAccelerationStructureKHR: {
+                android::base::beginTrace("vkCmdCopyAccelerationStructureKHR subdecode");
+                const VkCopyAccelerationStructureInfoKHR* pInfo;
+                VkCopyAccelerationStructureInfoKHR stack_pInfo[1];
+                pInfo = (VkCopyAccelerationStructureInfoKHR*)stack_pInfo;
+                reservedunmarshal_VkCopyAccelerationStructureInfoKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyAccelerationStructureInfoKHR*)(pInfo), readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyAccelerationStructureInfoKHR(
+                        globalstate, (VkCopyAccelerationStructureInfoKHR*)(pInfo));
+                }
+                vk->vkCmdCopyAccelerationStructureKHR((VkCommandBuffer)dispatchHandle, pInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyAccelerationStructureToMemoryKHR: {
+                android::base::beginTrace("vkCmdCopyAccelerationStructureToMemoryKHR subdecode");
+                const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo;
+                VkCopyAccelerationStructureToMemoryInfoKHR stack_pInfo[1];
+                pInfo = (VkCopyAccelerationStructureToMemoryInfoKHR*)stack_pInfo;
+                reservedunmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyAccelerationStructureToMemoryInfoKHR*)(pInfo), readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyAccelerationStructureToMemoryInfoKHR(
+                        globalstate, (VkCopyAccelerationStructureToMemoryInfoKHR*)(pInfo));
+                }
+                vk->vkCmdCopyAccelerationStructureToMemoryKHR((VkCommandBuffer)dispatchHandle,
+                                                              pInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMemoryToAccelerationStructureKHR: {
+                android::base::beginTrace("vkCmdCopyMemoryToAccelerationStructureKHR subdecode");
+                const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo;
+                VkCopyMemoryToAccelerationStructureInfoKHR stack_pInfo[1];
+                pInfo = (VkCopyMemoryToAccelerationStructureInfoKHR*)stack_pInfo;
+                reservedunmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyMemoryToAccelerationStructureInfoKHR*)(pInfo), readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMemoryToAccelerationStructureInfoKHR(
+                        globalstate, (VkCopyMemoryToAccelerationStructureInfoKHR*)(pInfo));
+                }
+                vk->vkCmdCopyMemoryToAccelerationStructureKHR((VkCommandBuffer)dispatchHandle,
+                                                              pInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWriteAccelerationStructuresPropertiesKHR: {
+                android::base::beginTrace(
+                    "vkCmdWriteAccelerationStructuresPropertiesKHR subdecode");
+                uint32_t accelerationStructureCount;
+                const VkAccelerationStructureKHR* pAccelerationStructures;
+                VkAccelerationStructureKHR stack_pAccelerationStructures[MAX_STACK_ITEMS];
+                VkQueryType queryType;
+                VkQueryPool queryPool;
+                uint32_t firstQuery;
+                memcpy((uint32_t*)&accelerationStructureCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((accelerationStructureCount)) <= MAX_STACK_ITEMS) {
+                    pAccelerationStructures =
+                        (VkAccelerationStructureKHR*)stack_pAccelerationStructures;
+                } else {
+                    readStream->alloc(
+                        (void**)&pAccelerationStructures,
+                        ((accelerationStructureCount)) * sizeof(const VkAccelerationStructureKHR));
+                }
+                if (((accelerationStructureCount))) {
+                    uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
+                    *readStreamPtrPtr += 8 * ((accelerationStructureCount));
+                    for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k) {
+                        uint64_t tmpval;
+                        memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
+                        *(((VkAccelerationStructureKHR*)pAccelerationStructures) + k) =
+                            (VkAccelerationStructureKHR)unbox_VkAccelerationStructureKHR(
+                                (VkAccelerationStructureKHR)tmpval);
+                    }
+                }
+                memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
+                *readStreamPtrPtr += sizeof(VkQueryType);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkQueryPool*)&queryPool =
+                    (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
+                memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdWriteAccelerationStructuresPropertiesKHR(
+                    (VkCommandBuffer)dispatchHandle, accelerationStructureCount,
+                    pAccelerationStructures, queryType, queryPool, firstQuery);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+            case OP_vkCmdTraceRaysKHR: {
+                android::base::beginTrace("vkCmdTraceRaysKHR subdecode");
+                const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
+                VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
+                const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
+                VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
+                const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
+                VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
+                const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
+                VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
+                uint32_t width;
+                uint32_t height;
+                uint32_t depth;
+                pRaygenShaderBindingTable =
+                    (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
+                reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
+                    readStreamPtrPtr);
+                pMissShaderBindingTable =
+                    (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
+                reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
+                pHitShaderBindingTable =
+                    (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
+                reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
+                pCallableShaderBindingTable =
+                    (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
+                reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
+                    readStreamPtrPtr);
+                memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (pRaygenShaderBindingTable) {
+                    transform_tohost_VkStridedDeviceAddressRegionKHR(
+                        globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
+                }
+                if (pMissShaderBindingTable) {
+                    transform_tohost_VkStridedDeviceAddressRegionKHR(
+                        globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
+                }
+                if (pHitShaderBindingTable) {
+                    transform_tohost_VkStridedDeviceAddressRegionKHR(
+                        globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
+                }
+                if (pCallableShaderBindingTable) {
+                    transform_tohost_VkStridedDeviceAddressRegionKHR(
+                        globalstate,
+                        (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
+                }
+                vk->vkCmdTraceRaysKHR((VkCommandBuffer)dispatchHandle, pRaygenShaderBindingTable,
+                                      pMissShaderBindingTable, pHitShaderBindingTable,
+                                      pCallableShaderBindingTable, width, height, depth);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdTraceRaysIndirectKHR: {
+                android::base::beginTrace("vkCmdTraceRaysIndirectKHR subdecode");
+                const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
+                VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
+                const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
+                VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
+                const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
+                VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
+                const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
+                VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
+                VkDeviceAddress indirectDeviceAddress;
+                pRaygenShaderBindingTable =
+                    (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
+                reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
+                    readStreamPtrPtr);
+                pMissShaderBindingTable =
+                    (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
+                reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
+                pHitShaderBindingTable =
+                    (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
+                reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
+                pCallableShaderBindingTable =
+                    (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
+                reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
+                    readStreamPtrPtr);
+                memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                if (pRaygenShaderBindingTable) {
+                    transform_tohost_VkStridedDeviceAddressRegionKHR(
+                        globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
+                }
+                if (pMissShaderBindingTable) {
+                    transform_tohost_VkStridedDeviceAddressRegionKHR(
+                        globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
+                }
+                if (pHitShaderBindingTable) {
+                    transform_tohost_VkStridedDeviceAddressRegionKHR(
+                        globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
+                }
+                if (pCallableShaderBindingTable) {
+                    transform_tohost_VkStridedDeviceAddressRegionKHR(
+                        globalstate,
+                        (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
+                }
+                vk->vkCmdTraceRaysIndirectKHR((VkCommandBuffer)dispatchHandle,
+                                              pRaygenShaderBindingTable, pMissShaderBindingTable,
+                                              pHitShaderBindingTable, pCallableShaderBindingTable,
+                                              indirectDeviceAddress);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRayTracingPipelineStackSizeKHR: {
+                android::base::beginTrace("vkCmdSetRayTracingPipelineStackSizeKHR subdecode");
+                uint32_t pipelineStackSize;
+                memcpy((uint32_t*)&pipelineStackSize, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdSetRayTracingPipelineStackSizeKHR((VkCommandBuffer)dispatchHandle,
+                                                           pipelineStackSize);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_ray_query
+#endif
+#ifdef VK_EXT_mesh_shader
+            case OP_vkCmdDrawMeshTasksEXT: {
+                android::base::beginTrace("vkCmdDrawMeshTasksEXT subdecode");
+                uint32_t groupCountX;
+                uint32_t groupCountY;
+                uint32_t groupCountZ;
+                memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawMeshTasksEXT((VkCommandBuffer)dispatchHandle, groupCountX, groupCountY,
+                                          groupCountZ);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawMeshTasksIndirectEXT: {
+                android::base::beginTrace("vkCmdDrawMeshTasksIndirectEXT subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                uint32_t drawCount;
+                uint32_t stride;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawMeshTasksIndirectEXT((VkCommandBuffer)dispatchHandle, buffer, offset,
+                                                  drawCount, stride);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawMeshTasksIndirectCountEXT: {
+                android::base::beginTrace("vkCmdDrawMeshTasksIndirectCountEXT subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                VkBuffer countBuffer;
+                VkDeviceSize countBufferOffset;
+                uint32_t maxDrawCount;
+                uint32_t stride;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawMeshTasksIndirectCountEXT((VkCommandBuffer)dispatchHandle, buffer,
+                                                       offset, countBuffer, countBufferOffset,
+                                                       maxDrawCount, stride);
+                android::base::endTrace();
+                break;
+            }
+#endif
             default: {
                 GFXSTREAM_ABORT(::emugl::FatalError(::emugl::ABORT_REASON_OTHER))
                     << "Unrecognized opcode " << opcode;